1 files changed, 347 insertions, 0 deletions
diff --git a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.cpp b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.cpp
new file mode 100644
index 0000000..85c92c9
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.cpp
@@ -0,0 +1,347 @@
+#include "learning-parts.hpp"
+
+/*
+# "How do you think we could show better understanding of the things we are disregarding?"
+# "If we do understand these, can you help us?  Do you know who can?"
+*/
+
+// idea of learning to keep well having more process time and
+// priority than risky behaviors
+
+/*
+idea of a secret group attacking a present group, and the attackers being
+the only channel to deal with it.
+        if we talk, we need nobody to _ever_ know this.  the walls all have ears;
+        I was one of them. [from eastern half of continent where a targeted
+        activist was living alone]
+*/
+
+using namespace habitstarts;
+using namespace intellect::level2;
+
+// Propose:
+// 	everything that happens is passed to a set of common habits.
+// 	these habits categorize, summarize, and pass to relevent habits.
+//	high level triggers are thus efficient, because they respond only
+//	to the group that applies to them.
+//	these habits must be learned.
+//	when providing a trigger at a high level, provide a way to get examples
+//	of what it should and should not trigger for.  this provides for learning
+//	how to do this.
+// the above looks like relevence to me.  propose learning it.
+//	to learn most effectively, apply to process of learning.
+//	how do we adjust from success or from failure?  need some attribute
+//	of scenario to store for next time, to respond to differently.
+//	so when we do something, we'll want to be able to store all information
+//	needed to learn to improve.
+// we can include in this the meaning of a concept, and add language translation.
+// is this 'apple'?  is this? yes, no.  then pattern recognition could engage
+// triggers.  later we'll want to propagate wrongness from failures.
+// likely we'll grow better if we use this on things before they have words.
+// 	// propose using random or exhaustive trial to find successes until habits develop
+// 	// and then using the same on possible structure matches of the data
+// 		// it may not work, we'll need to creatively grow data; reaonable start though
+
+static int __init = ([]()->int{
+
+	decls(link, source, type, target);
+	ahabit(link, ((source, s), (type, t), (target, dst)),
+	{
+		s.link(t, dst);
+	});
+
+	decls(linked, anything);
+	ahabit(linked, ((source, s), (type, t), (target, dst, anything)),
+	{
+		if (dst == anything) {
+			result = s.linked(t);
+		} else {
+			result = s.linked(t, dst);
+		}
+	});
+
+	decls(unlink);
+	ahabit(unlink, ((source, s), (type, t), (target, dst, anything)),
+	{
+		if (dst == anything) {
+			s.unlink(t);
+		} else {
+			s.unlink(t, dst);
+		}
+	});
+
+	decls(get, set);
+	ahabit(get, ((source, s), (type, t)),
+	{
+		result = s.get(t);
+	});
+
+	ahabit(set, ((source, s), (type, t), (target, dst)),
+	{
+		s.set(t, dst);
+	});
+
+	// we want the habits expressive enough to code efficiently in.
+
+	// constructors are tentatively abolished in the low-level habit language. (new-type-instance modifies, not creates)
+	// we have one constructor of concepts, and knowledge attachment to concepts.
+	
+	decls(make, know, concept, is, group, already, in);
+	ahabit(make-concept, (),
+	{
+		result = a(concept);
+	}); 
+	ahabit(know-is, ((concept, c), (group, g)),
+	{
+		if (c.linked(is, group)) {
+			throw an(already-in-group).link
+				(habit, self,
+				 "context", ctx,
+				 concept, c,
+				 group, g);
+		}
+		c.link(is, group);
+		result = c;
+	});
+
+	// separate habits and behaviors.
+	// behaviors are modifiable data run hy immutable habits.
+	// they use translation maps to move concepts between
+	// subhabits.
+	// 	translation map is just list of equivalent pairs
+	
+	// note: lisp can self modify; would need wrapper
+	// constructors to make functions and lists into
+	// concepts.
+	// 	remember can google how to debug lisp
+	// opencog does concepts within lisp already, is
+	// heavyweight with few habita.  just want goertzel's
+	// effort honored, he probably came up with it before
+	// I did.
+	// 	opencog has functions for pattern matching etc
+	// 	they arent self-modifiable, may not matter
+	
+	//decls(ordered, behavior);
+	// need args and result for sequence
+	//ahabit(habit-sequence, ((
+	
+	decls(list, nothing, next, previous, first, last, entry);
+	decls(add, to, until, each, item, remove, from, somewhere);
+
+	// list functiona are habits because ordered-behavior
+	// would use a list
+		// lists are being handled by providing a habit that
+		// can be engaged for every item.  it responds to the item.
+		// i was thinking it could be better to respond to the next-link.
+		// 	these are roughly the same thing.
+		// when doing an ordered behavior we want to act in response to
+		// going to the next step, so we can decide to.
+		// this maps to the step list item.  if result is to stop, list
+		// stops iteration.
+		// 	may want a more meaningful exploration of list. not sure
+		// list is mostly the [first-entry, last-entry, next, prev] structure
+		// can be handled innumerable ways.
+	// LIST STRUCTURE PROMISE
+	// should be a promise handled by habits? rather than
+	// a bunch of specific habits? but is ok for now
+	// 	is likely good for mind to discover
+	// 	promises and structures on its own
+	// 		but implementing them generally might speed dev up, dunno
+	ahabit(know-is-list, ((list, l)),
+	{
+		result = l;
+		(know-is)(l, list);
+		link(l, first-item, nothing);
+		link(l, last-item, nothing);
+	});
+	ahabit(know-is-list-entry, ((list-entry, l), (item, i), (previous, prev, nothing), (next, n, nothing)),
+	{
+		result = l;
+		(know-is)(l, list-entry);
+		link(l, item, i);
+		link(l, previous, prev);
+		link(l, next, n);
+	});
+	ahabit(list-first-item, ((list, l)),
+	{
+		result = get(l, first-item);
+	});
+	ahabit(list-last-item, ((list, l)),
+	{
+		result = get(l, last-item);
+	});
+	ahabit(list-entry-next, ((list-entry, i)),
+	{
+		result = get(i, next);
+	});
+	ahabit(list-entry-previous, ((list-entry, i)),
+	{
+		result = get(i, previous);
+	});
+	ahabit(list-entry-item, ((list-entry, e)),
+	{
+		result = get(e, item);
+	});
+
+	ahabit(list-add, ((list, l), (item, i)),
+	{
+		ref prev = (list-last-item)(l);
+		ref li = (know-is-list-entry)(
+				(make-concept)(),
+				item,
+				nothing,
+				prev);
+		li.link(item, i);
+		li.link(next, nothing);
+		li.link(previous, prev);
+
+		if (l.linked(first-item, nothing)) {
+			l.set(first-item, li);
+			l.set(last-item, li);
+		} else {
+			ref prev = l.get(last-item);
+			l.set(last-item, li);
+			prev.set(next, li);
+		}
+	});
+	ahabit(list-each-entry, ((list, l), (context, c), (action, act)),
+	{
+		ref cur = l.get(first-item);
+		while (cur != nothing && result == nothing) {
+			result = act(cur, c);
+			cur = cur.get(next);
+		}
+	});
+	// list-entry-remove could be pulled out
+	ahabit(list-remove, ((list, l), (item, i)),
+	{
+		result = (list-each-entry)(l, i,
+			ahabit(self-iter, ((list-item, i2), (remove-item, i)),
+			{
+				if (i2.get(item) == i) {
+					result = true;
+					ref prev = i2.get(previous);
+					ref n = i2.get(next);
+					if (prev != nothing) {
+						prev.set(next, n);
+					}
+					if (n != nothing) {
+						n.set(previous, prev);
+					}
+					i2.unlink(previous);
+					i2.unlink(next);
+					i2.unlink(item);
+					dealloc(i2); // hmm.  we do have an active goal of making memory allocation be habit based.  this might work here, though.
+				}
+			}));
+	});
+
+	using links_it = level0::baseref::links_t::iterator;
+	ahabit(populate-link-entry, ((link-entry, le)),
+	{
+		result = le;
+		auto & it = result.vget<links_it>();
+		if (it != result["source"].links().end()) {
+			result.set("type", it->first);
+			result.set("target", it->second);
+		} else {
+			result.unlink("type");
+			result.unlink("target");
+		}
+	});
+	ahabit(first-link-entry, ((concept, c)),
+	{
+		result = level1::alloc(level, c.links().begin());
+		result.set("source", c);
+		(populate-link-entry)(result);
+	});
+	ahabit(last-link-entry, ((concept, c)),
+	{
+		result = level1::alloc(level, --c.links().end());
+		result.set("source", c);
+		(populate-link-entry)(result);
+	});
+	ahabit(next-link-entry, ((link-entry, le)),
+	{
+		result = le;
+		++result.vget<links_it>();
+		(populate-link-entry)(result);
+	});
+	ahabit(previous-link-entry, ((link-entry, le)),
+	{
+		result = le;
+		--result.vget<links_it>();
+		(populate-link-entry)(result);
+	});
+
+	/*
+	ahabit(happened-habit, ((happened, ev)),
+	{
+		if (!happened.linked(whenever-list)) { return; }
+
+		ref stub = a(event);
+		stub.set(event, ev);
+
+		(until-each-list-item-context-in-list)(action-whenever-happened, stub, happened.get(whenever-list));
+	});
+
+	ahabit(action-whenever-happened, ((list-item, li), (event, h)),
+	{
+		// here: when we trigger a behavior, we want information associated with producing the trigger,
+		// as well as the event that triggered.  that's two contexts.
+
+		// list-item has item
+		// item has action and context
+		ref i = li.get(item);
+		// i think below we are proposing that handlers
+		// take one context, which is the one prepared
+		// in the list, then we inject our context
+		// into that, inside a "happened" property.
+
+		ref actctx = i.get(action-context);
+
+		actctx.set(happened, h);
+ 
+		i.get(action).fun<ref>()(actctx);
+	});
+
+	ahabit(whenever-habit, ((happens, ev), (action, act), (action-context, actctx)),
+	{
+		if ((action-context).linked(happened)) {
+			throw std::logic_error("happened on action-context");
+		}
+		if (!ev.linked(whenever-list)) {
+			ev.set(whenever-list, (make-list)(nothing));
+		}
+		ref list = ev.get(whenever-list);
+		// happens gets the list
+		ref item = a(whenever-action);
+		item.set(action, act);
+		item.set(action-context, actctx);
+
+		(add-to-list)(item, list);
+		// store ctx[action] on ctx[happens] as behavior to do
+		// store ctx[action-context] as context for behavior
+		// PROPOSE: automatically place [happened] inside [action-context] as a stub
+		// for call event objects, and then place [context] inside [happened].
+		// PROPOSE: report error if [action-context] contains [happened]
+		// 		as a stub for error patterns, it would be pretty nice to throw
+		// 		a unique concept ref for each error type.  plan to add to level-0.
+	});
+
+	ahabit(stop-when-habit, ((action, act), (happens, ev)),
+	{
+		// remove doing ctx[action] for ctx[happens]
+	});
+
+	ahabit(once-habit, ((happens, ev), (action, act), (action-context, actctx)),
+	{
+		// takes ctx[action] and ctx[happens] and ctx[action-context]
+		// uses above habits to do the action only once, probably by using
+		// a trigger on the habit-happening habit to check if a label is set,
+		// and remove the habit if it is.
+	});
+	*/
+
+	return 0;
+})();