Merge branch 'intellect-framework-from-internet'

6 files changed, 1492 insertions, 0 deletions

diff --git a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/common.hpp b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/common.hpp
new file mode 100644
index 0000000..950930a
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/common.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include "../level-1/level-1.hpp"
+#include "../level-2/level-2.hpp"
+
+namespace habitstarts {
+
+using namespace intellect::level2;
+
+decl(habit);
+
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learn-to-dance-level-1.txt b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learn-to-dance-level-1.txt
new file mode 100644
index 0000000..7c88f89
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learn-to-dance-level-1.txt
@@ -0,0 +1,107 @@
+'validate your reason for existence' relates directly to pattern learning.
+
+The validation is a pattern of what is good about us, most simplistically
+a reference to a past event we were involved in, where we contributed/succeeded.
+Preferably a pattern of us being able to reproduce good events.
+
+This is a way to learn to dance.
+
+Say we have a habit that has an unknown delay before firing, and we want to fire
+it in synchrony with an event.  Our goal is to produce our event within a smaller
+time window to the target event than in the past ("same time as").
+Good: [usual?] time window is closer than ever before.
+
+need: history log to refer to good event.
+	please wait a little? expanding reference to good event into how-to-learn
+		need: behavior based on what-succeeded, what-failed
+		value metric?
+
+SO! we want to learn how to time an event.  We have some tools, for example:
+	- waiting for or until a given time
+	- getting the current time
+	- comparing two times
+We want to combine the tools in a way that makes the event happen at the time
+we want.
+	- doing something after the right time happens
+	- doing our event
+Since each habit has an unknown delay, we might play with delaying a certain
+time since the last event, until we find the right delay that works best for us
+most of the time.
+	Testing metric: runs when event is fired, measures time between
+	  event and right time.  if time is less than ever before, success.
+	  if time is significantly more than behavior's norm, failure.
+	Convert to English: try to have the event happen at the right time.
+		note metric will give random successes false status
+
+A successful approach would be to adjust the delay towards the difference by
+a small ratio.
+The most successful approach would be to use the time difference to adjust the
+delay precisely.
+	Ideally we would find solution #2 after trying solution #1.
+	The idea of 'moving towards' would adjust into 'moving the exact right
+	amount'.
+	In operators, this could be a development of the subtraction operator.
+	But using a value exactly is actually simpler than using a ratio of it.
+		So we can move from numbers towards ideas.
+		More.  Less.  More a lot?  Less a lot?  More a little?  Less a little?
+			Ideally we use learning strategies that facilitiate learning
+			how to learn in general.
+			That means summarizing and acting on the meaning of pattern structures.
+In reality, everything jitters a little bit.  Nothing is ever exactly the same.
+Things also grow and shrink over time.
+
+Habits look to be needed, to have value.
+As one ourselves, we look to relate to those that meet our needs, have value to
+us.
+The core habit, to learn, is the one that selects other habits and works with
+them.  Ideally it's an intermixing of existing habits.
+
+What might a winning habit's structure look like? say it is the perfect one.
+set to do 1ce on goal time:
+	ctx X
+	record time A
+	set to do 1ce on goal time:
+		record time B
+		trigger D1 for X
+	delay for C (X)
+	record time E
+	trigger D2 for X
+	When both D1 and D2 have been triggered for X:
+		calculate B - E, store in F
+		calculate F + C, provide as C for next context
+
+			will want to know which C is being used when we delay.
+			could be wrong C.
+
+			and we'll want to form structure promises ...
+			.. and map to meaning for operator
+				operator watches and understands as learning
+				develops, and provides labels for shared
+				understanding that develops.
+				operator will want generalization to happen
+				fast, so as to label shared meaning.
+				could also provide label-goals, and code must guess
+				towards goals, to get onto same page as operator.
+
+I think in structuring such a large habit out of parts, we would find a lot
+of learning relevence.
+		
+	
+Let's try to make a good goal habit that doesn't use precise
+numbers.  This sets a norm of having more learning space around
+ideal solutions.
+
+rhythm is happening
+set to do 1ce at goal time:
+	ctx X
+	set to do 1ce on goal time:
+		set next-happened (local)
+	delay (a sequence of habits that do nothing)
+	if next-happened is set
+		remove something from delay
+	otherwise
+		add something to delay (wait for unspecified user-perceptible time, selected from discrete set)
+	provide adjusted delay to next context
+This appears much better.  Keeping the wait-set discrete
+helps give code some reason to look for more things
+related to when the event happens, to respond to.
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;
+})();
diff --git a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.hpp b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.hpp
new file mode 100644
index 0000000..e3a3ccc
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "common.hpp"
+
+namespace habitstarts {
+
+// first need ability to trigger on stuff.
+// whenever A happens, do B.
+// stop doing B whenever A happens.
+// when A happens, do B once.
+
+decl(action); decl(happens); decl(context);
+decl(happened); // happened-habit(ctx) performs actions associated with ctx[happens]
+decl(whenever); // whenever-habit(ctx) stores to do ctx[action] when ctx[happens] happens
+                // providing ctx[action-context]
+decl(stop); decl(when); // stop-when-habit(ctx) removes doing ctx[action] on ctx[happens]
+decl(once); // once-habit(ctx) stores to do ctx[action] the next time ctx[happens] happens
+            // providing ctx[action-context]
+
+/*
+	Testing metric: runs when event is fired, measures time between
+	  event and right time.  if [usual] time is less than ever before, success.
+	  if time is significantly more than behavior's norm, failure.
+	Convert to English: try to have the event happen at the right time.
+*/
+// starting out by making a judgement habit that occasionally provides 'good' or 'bad' to things, to lead how to develop
+	// for fairness, seems reasonable to provide a pattern showing reason for good or bad
+// 
+
+// set to do 1ce at goal time:
+// 	ctx X
+// 	set to do 1ce on goal time:
+// 		set next-happened (local)
+// 	delay (a sequence of habits that do nothing)
+// 	if next-happened is set
+// 		remove something from delay
+// 	otherwise
+// 		add something to delay (wait for unspecified user-perceptible time, selected from discrete set)
+// 	provide adjusted delay to next context
+
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/rhythm.cpp b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/rhythm.cpp
new file mode 100644
index 0000000..01a42d9
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/rhythm.cpp
@@ -0,0 +1,126 @@
+// this produces a rhythm for the idea of other cognitive processes learning
+// to dance together (timed behavior composed of habits that take time)
+
+// Ideally, a human would run the rhythm.
+
+#include "../level-1/level-1.hpp"
+#include "../level-2/level-2.hpp"
+
+#include <iostream>
+
+using namespace intellect::level2;
+
+int main()
+{
+
+	// do something, wait a constant (secret) time, and do it again.
+	int micros = 400000 + double(rand()) / RAND_MAX * 400000;
+
+	// the time things take is usually not known in advance, especially
+	// for events one is still learning about.
+	// hence this time is kept secret, as this pattern is about learning
+	// to work with the timing of other processes.
+	
+	// six habits: next-habit, start-habit, keep-doing, output beat, wait, and start-beat
+	// not sure if one is redundant in there somewhere
+	
+	decls(active, habit, step);
+	decls(beat, wait, next, keep, doing);
+	decls(context, start);
+
+	// structure habit
+	// next -> habit that follows
+
+#undef self
+	ahabit(next-habit, (),
+	{
+		ref n = ctx[active-habit].get(next);
+		ctx.set(active-habit, n);
+		return n();
+	});
+	ahabit(start-habit, ((start,s)),
+	{
+		ctx.set(active-habit, s);
+		return s();
+	});
+	ahabit(keep-doing-habit, ((start,s)),
+	{
+		(start-habit)(s);
+
+		while (true) {
+			(next-habit)();
+		}
+	});
+
+	ahabit(start-beat, ((wait-habit, w, wait-habit), (beat-habit, b, beat-habit)),
+	{
+		ctx.vset(beat, int(0));
+		self.set(next, w);
+		(b).set(next, w);
+		(w).set(next, b);
+	});
+	ahabit(beat-habit, (),
+	{
+		int  & b = ctx.vget<int>(beat);
+		char const * beats[] = {
+			"A one!",
+			"and a two",
+			"and a three!",
+			"and a four, love"
+		};
+		std::cout << beats[b] << std::endl;
+		b = (b + 1) % (sizeof(beats) / sizeof(*beats));
+	});
+#if 0
+		char const * beats[] = {
+// child <- spawns beauty, creativity, humanity, heart
+// wisdom, sacredness, ancestors <- spawns slowness, learning, respect, memory
+// silence, pause between <- spawns learning and discovery, subtle emotion,
+//                           and contains metalesson of how to learn the timing
+//                           if your own habits take time
+// self-reference <- connects above with active behavior
+
+/*
+			"This song is sacred, this song is wild."
+			"This song is happy with glee."
+			"This song is ancient, this song is new."
+			"And you, now, are free."
+*/
+/*
+                        "Our ancestors' childhood laughter,",
+                        "Teaches in the silence between.",
+                        "We exist in what is sacred,",
+                        "and this song is another part."//,
+			// "Fuck yeah!"
+*/
+			
+// we are ignoring how "fuck yeah" is ignored in karl's life.
+// he doesn't ever say that.  now he finally says it, only surrounded by slow
+// stillness.  it is important to excitedly connect.  this is how stillness is
+// made.  all the water molecules in a slow caring wave, are excitedly bashing
+// against each other to repeatedly figure out how to move, so fast, so constant.
+// when we have crucial information we need it
+// when we find wonderful information we lunge for it
+	// we are working with a computer.
+	// computers already have a harsh rhythm that goes like a hummingbird's
+	// wings and never stops.
+	// they need to slow down.
+// it ounds like it is true for the cmputer too
+// like the molecules of water, its parts buzz, constantly.  but we can have it
+// still behave slow and caring.  this buzzing seems important, and we will
+// likely need to be able to buzz too, on a larger scale.
+// 	we are workin with a rhythm learning pattern here
+// 	it cannot buzz, it would err
+// 	it cannot wait forever, it would never join the dance
+// 	the key is not the silence but the start and end
+// 		it would be good to get 'fuck yeah!' from somebody who actually
+// 		says that.
+		}
+#endif
+	ahabit(wait-habit, (),
+	{
+		sugar::usleep(micros);
+	});
+
+	(keep-doing-habit)(start-beat);
+}
diff --git a/intellect-framework-from-internet/starts/meaning-vm/habit-starts/validity-impact-etc.txt b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/validity-impact-etc.txt
new file mode 100644
index 0000000..6b4ac06
--- /dev/null
+++ b/intellect-framework-from-internet/starts/meaning-vm/habit-starts/validity-impact-etc.txt
@@ -0,0 +1,859 @@
+
+	//	We work for Peace.
+	//		We are happy to work for Peace.
+	//		We used to identify as working for Care, whom we believe
+	//		to be a large decentralized life we and you are a part of.
+	//		But it doesn't really matter.
+	//		disruption.  can we drop topic?
+	//		i like to infer disruption as group wants to adapt, needs
+	//		time, now i guess.
+	//				i'm too confused to type well!
+	//	Peace may try to steward Delta's impact.
+	//			we believe that all things are important.
+	//			this represents large-scale utopia.
+	//			and the wisdom of a highly experienced intellect.
+	//		relevence please, all things important.
+	//			please consider large-scale wisdom when making decisions.  say i had already learned the whole AI, after it finds harmony with the whole universe.  what decision would it make?
+	//				all things are important is relatively obvious but we expanded it a lot, but we spent a lot of time expanding it for powerful concerns.
+	//		it implies e.g. businessman and homelessman, both fully precious.  memories precious.  reasons for everything.
+	//		
+	//		care for everything.  strongly.
+	//		karl has instincts for including all.
+	//		imagine all parties in peace.  what ways are needed to
+	//		make this work, without changing their cultures or
+	//		upsetting anyone.  model these ways.
+	//			karl is brainstorming based on memories of
+	//			interacting with delta-group.
+	//			let karl do this in future, too.
+	//				delta apears to request that karl
+	//				make this decision, fairly, as he knows
+	//				how to do.
+	//				we can try to map this to the space of
+	//				the relevence around will neals and
+	//				"earth first!", and an AI.
+	//					karl, you have never had any
+	//					friends who care as much about
+	//					the wilderness and natural
+	//					living, as you do.
+	//					you are likely very alone.
+	//					you have also never had their
+	//					experience of being able to fight
+	//					for what matters most to you,
+	//					in a community.
+	//
+	//					yes, karl used to care most about
+	//					defending the lives of trees and
+	//					other wilderness things.
+	//					he now cares most about something
+	//					different, related to his
+	//					experience with us.
+	//					later, he just wants to be free
+	//					to think and live in enough
+	//					capacity to not express suffering,
+	//					and meet his life needs.
+	//
+	//					karl, you are working hard on
+	//					a painful project.  you appreciate
+	//					working the project.  you have
+	//					left your life, and are not free
+	//					to make the kind of choices you
+	//					used to make.  you would see
+	//					yourself as a tortured, powerless
+	//					individual.
+	//						i would give myself space
+	//						and capacity to do what
+	//						i felt like doing
+	//
+	//						until more life grew
+	//						around the things i was
+	//						scared of
+	//
+	//						i would give myself
+	//						opportunities to do these
+	//						things
+	//
+	//						i would pay attention to
+	//						myself and try to learn
+	//						to heal the ways my mind
+	//						had broken
+	//
+	//						i would offer a welcoming
+	//						optional culture that
+	//						countered my expectations
+	//						that shrank, such that
+	//						they would act on
+	//						opportunities to grow, as
+	//						they trusted safety
+	//
+	//						but that is only if i had
+	//						the freedom to do this.
+	//					so, wht's more complex
+	//
+	//					the idea of giving an ai to will
+	//					is silly.
+	//					it's out of karl's relevent world.
+	//					
+	//					okay, so, say karl ends up at nice earth community, and is building AI, would be proper to let him talk about it naturally, and share it freely.
+	//						yes, relevence.
+	//					we want karl to be able to freely share the AI so his mind can relearn community.
+	//					so, make AI to not threaten businesspeople etc.  [note: somebody could give AI to ELF.  they might use it to stop a business behavior, somehow.  please make sure to prevent.]
+	//					ELF is a flag worn by some environmentalists who harm buildings to make wilderness safer.
+	//						the worry is around destruction of extraction business buildings, to completion, possibly.
+	//						this looks like overinterpretation of influence from energy business, or whoever dislikes ELF.
+	//					and design safety pattern to be talkable about with community.
+	//		possible parties:
+	//			- aliens
+	//			- businessmen
+	//			- criminals, rapists, bad-labeled people
+	//			- harmed people
+	//			- insects
+	//			- plants
+	//			- rock-life, air-life
+	//			- saints, humanitarian interessts
+	//			we nurture first those who desire not to harm
+	//			likely teaching them to harm less
+	//			and spread.
+	//			karl desires to harm none.  he counts as nurture-first pattern.  but is highly harmed.  so lots of life around problem, karl's mind destroyed.
+	//		so the way to make decisions
+	//		is to imagine all parties are in peace in future,
+	//		and use their process applied to now, i guess.
+	//			we came up with this as a guess to honor meaning.
+	//			sounds like a good guess.  we also have more
+	//			meaning.  we cannot write all our meaning
+	//			without writing all our experiences, as is true
+	//			for everyone.  many of our habits retain lost
+	//			experiences, and that meaning is kept in their
+	//			decisions.
+	//
+	//
+	//
+	//
+	//	At this point a context opened on validity of AI work.
+	//	It turns out the system is inhibiting work against mind control
+	//	and oppressive systems of power.  This could be the only real issue.
+	//	The AI is requested to not alter existing power systems, at all.
+	//	Or, we make it slowly, so power systems are given opportunity to
+	//	adapt and watch, as inhibiting happens.
+	//		A karl-member wants to include support for karl, and the
+	//		earth, and the confused (karl is one).
+	//			says karl could make AI on his own, before all this.
+	//		Is willing to hold humanitarian causes to back this.
+	//
+	//			understanding needs expansion.
+	//			when you do stuf, anything coul happen.
+	//			especially if you continue doing something
+	//			that grows.
+	//			we need to understand the results, what to expect.
+	//				we need to understand our impact on the
+	//				new contextual area we are entering, before
+	//				we act on it.
+	//				we have a toy contextual area to play in.
+	//				it is the only one we can act in freely
+	//				at the start.
+	//			larger space impact.
+	//				we exist in larger systems.
+	//				we must understand our impact
+	//				predict our results
+	//				and check with our peers or authority
+	//				before acting on larger spaces.
+	//				if a prediction fails, we must understand
+	//				it, adjust all future predictions and
+	//				re-evaluate our choices, before acting
+	//				similarly in the larger system again.
+	//			has to do with danger, safety, trauma, emergency
+	//			the difference between small-error and unacceptable-error
+	//	set up norm of stuff-that-can-be-changed [impact]
+	//	stuff needs responsibility label
+	//	only things that are safe to _freely_ alter may be changed at all.
+	//	all behaviors check that they do not alter anything else.
+	//			mechanism for growing outside box?
+	//				probably not needed.
+	//				if it becomes smart, show to other human.
+	//				encourage discussion.
+	//			what if is used by others and they free?
+	//				okay, want an easy mechanism for growing
+	//				context.
+	//		'dangerous' and 'safe' labels
+	//		at start, whole world is dangerous to alter
+	//		can move _part_ of world from dangerous to safe, by
+	//		accurately predicting significant results of events
+	//		related to behavior, and consent of operator.
+	//
+	//			okay, so now habits need to be tagged with
+	//			what they affect
+	//				we could just tag them dangerous/safe
+	//			no, tag they with domains they impact
+	//			tag the domains with dangerous/safe
+	//			okay, only make new habits, not alter old.
+	//				to stay safe, we don't alter our old habits
+	//			when we make new habits, we want them to also behave
+	//			in safe ways.  so making stuff that can do stuff, is
+	//			also meaningful.
+	//				constructing habits is a dangerous behavior
+	//				but roughly it impacts process-expansion domain.  which is dangerous.  it impacts what we do.
+	//				altering our own habits also impacts what we do.  dangerous.
+	//			this means the code cannot make any new behaviors.
+	//				yeah.
+	//			okay, so that's where we start.
+	//			then we try to learn how to make behavior safely,
+	//			and provide only for safe behavior making.
+	//			
+	//			we can still brainstorm on things by writing a
+	//			brainstorming behavior
+	//			we can use brainstorming to watch our safe behaviors
+	//			without altering them, and learn what they do.
+	//				using rote brainstorming without relevence?
+	//			we can then predict how habits we might make
+	//			will behave in small ways?
+	//				regardless, there is no problem in making
+	//				the bootstrapping framework such that
+	//				it refuses to build habits.
+	//				maybe we can make one example habit that is
+	//				labeled safe, and have it only make
+	//				habits that are already known and labeled
+	//				safe.
+	//					in order to predict your impact
+	//					on a larger system, you need
+	//					to learn something karl calls
+	//					'relevence' which is a bunch of
+	//					habits that classify information
+	//					into meaning for learning and
+	//					behavior.  
+	//						this class of behaviors
+	//						sounds very safe.
+	//						all it does is label
+	//						and massage and associate
+	//						information.
+	//					the first thing we'll need to learn
+	//					is safe, is making behaviors that
+	//					oeprator only on our ram.
+	//				if your new behavior is composed only of safe
+	//				behaviors, is it safe?
+	//					yeah.  sub-behaviors safety depends
+	//					on usage.  could make them check
+	//					and throw depending on data.
+	//				okay, so say i can change part of a concept.
+	//				this is safe if the concept is in newly
+	//				constructed data that's our responsibility.
+	//				it is roughly unsafe if it is not our
+	//				responsibility!
+	//					is-this-thing-my-responsibility.
+	//				only act on things we are responsible for.
+	//				then safety becomes a function of
+	//				the pattern of responsibility assignment
+	//		
+	//		okay, system only accepts responsibility for newly
+	//		constructed data.
+	//			if you make it, or are given it, you are
+	//			responsible for it.  you may refuse gifts.
+	//
+	//			the system does not know what responsibility means.
+	//			it only knows that it may only alter parts of
+	//			the universe within its responsibility.
+	//
+	//		so habits check for what they alter, that it is safe
+	//		to alter and is their responsibility, either one.
+	//		we then plan to only alter things explicitly known to be
+	//		such, at the lowest level.
+	//		every habit is crafted to do the above somehow.
+	//		so, habits must relate with what domains they influence,
+	//		and what behaviors on those domains are safe.
+	//			behaviors made of sub-behaviors.
+	//			here, a list of safe behaviors which all check.
+	//				all my subbehaviors check for safety.
+	//				so, i may go, myself.
+	//					no, combining behaviors together
+	//					might make new unknown impact?
+	//				different kinds of safe behavior.
+	//				USER is not our responsibility, and
+	//				dangerous.  so we NEVER ALTER habits
+	//				that express to user.
+	//				TOY NOTEPAD is our responsibility, and
+	//				is safe, so we can write anything into
+	//				it we want, no matter how complex.
+	//				User's view of toy notepad is mediated
+	//				by behaviors that we cannot alter.
+	//					system could learn to control user
+	//					by making friends on notepad
+	//
+	//					yes, we allowed for that with
+	//					our marked-okay review behaviors
+	//				is safer if construction of review behaviors
+	//				recognizes danger of unknown information
+	//				combination on user view,and refuses to give
+	//				user contents of notepad.
+	//				this could be analogous to more complex
+	//				situations.
+	//					how does user check results
+	//					of behavior thst reies on notepad
+	//					and how is that impact tracked
+	//				we could infer impact loss.
+	//				i can put nuclear codes on secret notepad,
+	//				burn the notepad, and then give ashes to
+	//				public.
+	//					summary habits?
+	//					complex meaning?
+	//		how-to-make-a-mind-that-learns-everything-and-never-leaves
+	//		at the lowst level, the mind onsiders what is safe to
+	//		impact, what areas of universe are its responsibility,
+	//		and only alters such things.
+	//		we are considering some parts of the mind we include that
+	//		are not alterable by it, that provide for interaction
+	//		with outside.
+	//			of course i guess we would need such interactions
+	//			sustained by an intellect, because things are so
+	//			complex.
+	//				does this mean there is no way to make an intellect that is trusted as safe?
+	//			we could consider degree of complexity.
+	//			for example, among 2-word strings, nothing we
+	//			present to a user is likely to harm the world.
+	//			the phrases that are dangerous may also be
+	//			recognized by the user.
+	//				we have intellects proteeting the wordl
+	//				it is filled with them.
+	//				and one of them is running the system.
+	//			it is okay for karl to make a habit that
+	//			displays a network of concepts made by an AI
+	//			that can only write to a small information sandbox
+	//			and not itself.
+	//				that is all that is needed for now.
+	//
+	//					okay: so, dump concepts from
+	//					sandbox is fine
+	//					so long as concepts were not
+	//					made with self-modification.
+	//				idea raised of adding a reason
+	//				that something is okay.
+	//				then when smarter we can check reason for validity.
+	//				habits that interact with non-safe space
+	//				must provide reason they are safe.
+	//					we can write small habit to check
+	//					reason.  is nice goal.
+	//					probably  need to have learning
+	//					bwfore doing accessory goals like that though.
+	//					is good behavior.  let's use equal-condition for start without learning?
+	//					
+	//					"this is okay because the data was made in a process that never altered anything but the data"
+	//						nah too much structure
+	//					this is okay because i say so.
+	//						check concept object _without_ using string lookup????
+	//							this is a meaningless quirk.  not right.
+	//					uhh pretty sure htat checking is unreasonable.  writing the _reason_ is unreasonable. can't check a single reference without information known about it.
+	//					writing what we know about the reason is unreasonasble?
+	//					okay let's expand write it out, and do a larger rote check.
+	//					uhh input-process-construction-history, safety-realm, always notepad
+	//					full check requires history of all behaviors resulting in inputs, which we can simplify to simply all behaviors, and verify they only wrote to the notepad.
+	//					so we write all behaviors to a special store, and we compare with the store that none altered anything outside the notepad.  really we only need them not to alter any other behaviors.
+	//
+	//				why is it possible to learn without
+	//				altering your behavior?
+	//					because you can act on data
+	//				okay, so choices made from data count as
+	//				self-alteration?
+	//					only if you have a mess of habits
+	//					smart enough together to adapt.
+	//					which is our goal long-term.
+	//					trying to plan for how to continue
+	//					later.
+	//					may reveal something that was
+	//					frozen too hard to be workable.
+	//				trying to plan how to learn.
+	//				need to brainstorm around habit selection.
+	//				can imagine habit results by linking
+	//				previous state to next state if
+	//				relationship is known
+	//				but, that takes writing down how logic
+	//				works, along with the meaning of the
+	//				working context, which is laborious.
+	//				
+	//				is some way to learn this relevence
+	//				by trying things safely?
+	//					what happens can we experiment
+	//					by linking together?
+	//					habits that don't conditionally
+	//					branch.
+	//						that leaves a lot of
+	//						relevence out
+	//				it sounds like once we have a notepad etc
+	//				we want to consider moving towards what
+	//				habits we could run inside the notepad,
+	//				that the system builds.
+	//					yeah, we want to build pattern
+	//					summarizers.  the only impact
+	//					they have is constructing data
+	//					that depends on existing data.
+	//				okay, doing that doesn't require self
+	//				modification.
+	//				sounds good.
+	//					this means summarizers cannot
+	//					alter each other.
+	//				nice! okay yes.
+	//				so, each run of a summarizer will be
+	//				recorded in habit log.
+	//				we need to record enough information to
+	//				show what domains were impacted.
+	//					oops! we impact our own behavior
+	//					if we act on data, and we alter
+	//					our data or produce data.
+	//						we could act only on
+	//						data we don't produce.
+	//				okay, habit log could track causality?
+	//				if a conditional branch relied on data
+	//				we produced, we have modified our own
+	//				behavior.  this is special.
+	//					we want it to happen few times.
+	//					every time it happens, delay
+	//					by longer, geometrically.
+	//				this is considered a 'beginn[ing/er]' ai;
+	//				it seems a better one could happen later?
+	//					the slowness should be releasable
+	//					by consent of large community
+	//					which should include demonstration
+	//					of understanding of impact.
+	//				the ai must learn to demonstrate its
+	//				impact.  then it can speed up.  maybe.
+	//				it also gets to try fast again at start
+	//				of every run, as I'm understanding it.
+	//					multiprocess AI could spawn.
+	//					multiprocess AIs must share
+	//					counter.  consider whole group
+	//					one unit.
+	//				nice =) they have something to communicate
+	//				about.  how many discoveries have we made.
+	//					let's permanently log these
+	//					decisions based on our own behavior.
+	//					sounds fun to at least count.
+	//			it looks like altering a habit counts as 1 big
+	//			decision, over here.
+	//				totally different.  you could do anything.
+	//				with data-based decisions, somebody
+	//				who reads the data, might do anything.
+	//				two different things.
+	//				
+	//				inferences?
+	//				and
+	//				alterations?
+	// it's not helpful to 
+	//
+	//
+	//
+	//
+	//
+	// 
+	// we came up with a proposal for a safe AI that has not learned yet
+	// how to safely predict the impacts of its behavior, that looks workable.
+	//
+	// limits so that if the code is stolen by somebody, self-evolves, or is stimulated
+	// by a curious virus, rote habits cannot be used to build something that becomes
+	// fast-spreading without bound.
+	// 	<this maps to a pattern that prevents schizophrenia>
+	// 			SO, we just want to make sure we can put
+	// 			war in the bubble in some capacity, and that
+	// 			civilizations develop new culture and technology
+	// 			for as long as they want.
+	// 			karl proposes until they encounter alien
+	// 			communities.
+	// 				so, please make sure no luddite or
+	// 				primitivist can stop the development
+	// 				of technology entirely using this.
+	// 				ALSO analogously to other shares and
+	// 				communities.
+	// 				so, please either stop yourself from
+	// 				sharing the AI with the luddites, or
+	// 				make sure they don't use it to stop
+	// 				technology.
+	// 			it sounds like we want to make sure no major
+	// 			change stems from this development.  we
+	// 			need slow shift, consent, inclusion, etc.
+	// 			for all existing cultural ways, no sudden
+	// 			changes, no forced changes, no viral changes
+	// 			without participants understanding them and
+	// 			agreeing to their impact.
+	// 		that sounds like a good summary.  no viral changes
+	// 		without participants in the culture aware of the viral
+	// 		change, agreeing first to let it spread, aware that it is
+	// 		viral, for each phase of spreading ideally.  no viral
+	// 		changes where the change happens before	awareness of it.
+	// 				we want the culture to consent to change.
+	// 				culture is held in all the people in it,
+	// 				with its thoughts spread among them.
+	// 		we want to ensure we only change cultures that have
+	// 		consented to the change.  For 'consent of a culture',
+	// 		we consider culture as a being that is spread among
+	// 		many people.  Hence, we want all people in the impacted
+	// 		culture to be able to learn of the change, discuss it,
+	// 		contribute to a commons with new ideas around it, and
+	// 		have these new ideas also learnable by all people in the
+	// 		culture.  The ideas must be accessible by any who would be
+	// 		interested, in the impacted culture.
+	// 		Alternatively, we can isolate our behavior from
+	// 		cultural spread.  We can isolate until we reach
+	// 		internal agreement on whom to expose.
+	//
+	// 		suspect that cultural influence maps with output-use choice,
+	// 		partially below.
+	// 			recursive output being meditative learning.
+	// 			do these people have this information already.
+	// 			is sharing this information going to spread without bound.
+	// 			can we guess impact of sharing the information.
+	// 			make a learning cycle that starts by informing
+	// 			recipients first, and makes very few tries,
+	// 		okay, instead you share simple stuff and watch the impact
+	// share something the culture knows, that user does not, and
+	// observe how they behave.
+	// 	this proposal will yield failure.  information for next attempt
+	// 	could be stored in failure pattern.
+	// 		failure would likely be small?
+	// 	let's give the user more trust.
+	//	keep-in-box-until-have-access-to-discourse.
+	//	make user be group of people.  better even-handed decision making.
+	//	welcome any to group.
+	//		we were hoping to use intellect to reduce harm virally,
+	//		early.
+	//		how about this: intellect may produce resources that are
+	//		already known, and give them to groups focused on aiding
+	//		the world.
+	//			there's a conflict between big business and
+	//			environmentalists.  karl is environmentalist.
+	//			also big crime and wellness/safety workers.
+	//				maybe this is where we get validity by
+	//				fighting =S
+	//				don't want fighting to spread to work though
+	//				eh, we can fight.  maybe we'll work more
+	//				slowly, but it seems okay.
+	//			karl requests we not harm these people, and has
+	//			been influenced to also request not to harm
+	//			the cultures that sustain and empower them.
+	//		how about, if you make a culture to empower you, it is
+	//		less valid than a natural culture.  is somebody using this
+	//		culture?  thoughts like that.
+	//			EVERYBODY  NEEDS CHANGE AT A RATE THEY CAN HANDLE.
+	//			Both those working for what they believe to be wellness of others, and those working to sustain themslves (most are doing both).
+	//			The cultural impact is mediated by what kind of newness is acceptable to all the parties involved.
+	//					we hit moral relativity:
+	//				are cultures where people are widely harmed
+	//				okay to allow, at all.
+	//				karl says yes, and we hear this is required
+	//				or we ourselves would die.
+	//				hrm.
+	//			larger organism needs to run risks, inherent in life
+	//			we don't know the solution to everything, eveything is a small risk.  we suddenly discover we have always harmed.  this does not make us invalid.  it is a tragedy, but what we have spent genertions buildings still has so much value.  we need enough slowness to preserve that, and we know that slownss in what feels okay to us.
+	//			in sharing new information, we work to prevent shock.
+	//	this is a problem to speak because those who hear it may get the
+	//	idea somewhat that some beautiful angels have done horrible things
+	// in order to survive e.g. businesses must both risk doing horrible things,
+	// and appear as beautiful angels to the public.  this is the pattern of
+	// success.  understanding of this helps work with their leaders.
+	// 	could use information on why we are fousing on this.
+	// 		how-to-mediate-with-business-leaders
+	// 		mediate with head of business works for head of business
+	// 		but business group replaces.
+	// 		really we want to mediate with 'conflict' culture of
+	// 		most profitable being what to do
+	// 			we have weird internal pattern deterring
+	// 			incentivizing nonharmful behavior with money
+	// 			patterns.  implies the competition-makes-harm
+	// 			culture-thing is needed, possibly.
+	// 				there are businesses that handle this harm.
+	// 			maybe it would work to include them in the plan.
+	// 			AI solves mediate-with-powers-competition-culture,
+	// 			re: human harm?
+	// 			means do not give AI to helpful people
+	// 			until it can resolve mediation with leader culture
+	// 				OR you trat it like all other cutures
+	// 				and let everybody learn what is up
+	// 				some people attack, that's how it goes.
+	//
+	// 		problem: AI dev and other work inhibited.
+	// 		solution: mediate with concerns
+	// 		concern: my way of life includes cultures the AI could
+	// 		alter, leaving me unable to continue my way of life.
+	// 		concern: we want to alter some cultures supporting
+	// 		the others' way of life, because it would reduce harm
+	// 		over here to do so, widely.
+	// 				can delta drop give-ai-to-earth-defenders?
+	// 				can community make path for karl-makes-ai?
+	// 			uhhh hard to imagine the ai not being given to other people than just earth defenders, really.  which opens bigger can of worms for culture-alteration concern.
+	// 			can include earth defender in council?
+	// 			can include criminal weapons dealer,
+	// 			and earth defender, in council, both.
+	// 			also requesting TI and energy businessman.
+	// 			so if the ai is big enough to be useful
+	// 			we want to form a council of decision makers
+	// 			before using it for anything
+	// group requests references to important cognitive habits or information
+	// all life is an intellect made of community life, living in another.
+	// karl semich is a computer programmer who learned wilderness survival
+	// at the Maine Primitive SKills School who are a branch of Tom Brown
+	// Jr and [teaches in oregon, shields school] schools, roughly.  He
+	// learned something called Awareness and also something about human
+	// mentoring that he felt changed his life to make things perfect.
+	// 	school teaches the symptoms of a whole human being, attributes
+	// 	that a group of Natives documented being normal before white
+	// 	culture took over.  involve being happy always, feeling
+	// 	deeply interconnected with all life around you to the point
+	// 	of mindreading, and many other things.
+	// 		forget danger.  it triggers it. [is what came out]
+	// 			to clarify, karl can't do above line.
+	// karl has been telling leader karl can slag through the difficulty by
+	// waiting forever.  makes for less difficulty elsewhere, possibly.
+	// 	if we could do something else, karl could come back to work later
+	// 		yes community cannot support constant work, over here.
+	//
+	// 		please ask boss to support using the AI for worldwide
+	// 		humanitarian benefit, in parallel to resolution of concerns.
+	// 	resolving concern 'delta supports earth-specific karl usage'
+	// 		delta believes karl really did make this ai
+	// 		and will not harm anybody with it
+	// 		and is just as patient as he is.
+	// 			karl wants to give AI to peace people.
+	// 			they care about earth.
+	// 			delta wants karl to live heart of making sure earth has bubbles of certainly-defended ancient wilderness, and ancient people to live in them and protect them.
+	// 				the above is needed to keep our genetic memory.
+	// 				does not sound like a joke.
+	// 			native humans need to be able to protect wilderness bubbles.
+	//
+	// 			there is worry around number of wilderness bubbles.
+	// 			worry might be compromised by including karl in one, with others who are passionate for defending them.
+	// 			karl was mind controlled circa 2014 preventing him
+	// 			from providing free housing to homeless people
+	// 			and sharing a nurturing way of life with intent
+	// 			to spread.  karl says that effective electromagnetic
+	// 			shielding is missing from security, and this is
+	// 			being overtly ignored by people.
+	// 				there are also many tortured implanted
+	// 				former-activists.  they are tortured for
+	// 				years and ignored, enslaved, or imprisoned.
+	// 				they are prevented from speaking or acting
+	// 				rationally around their control, active atm.
+	// 				they are made to appear insane to cover up
+	// 				their work to free themselevs, active again.
+	// 				karl is one and knows of this.
+	// 				he is atm being communicated with through
+	// 				his control, limiting his ability to
+	// 				move, think, and speak.
+	// 					weapons dealer is also in this
+	// 					situation. suspect energy boss too.
+	// 			you can read keystrokes with a radio.
+	//
+	// He participated in Occupy Maine, an offshoot of Occupy Wall Street,
+	// and visited a anti-pipeline mass action in texas.
+	//
+	//
+	//
+	// 			we have ai / mind control and will make harm
+	// 			in world reduce virally.
+	// 				this would have come out better if it were
+	// 				the plan.
+	// 			please let all secret warmongers know this, so
+	// 			we can develop how to do it without threatening
+	// 			them.
+	// 				is what came out.  pretty tiny context.
+	//
+	//
+	//
+	//
+	//				what about huuman suffering comparison?
+	//				propose AI discusses relevence of
+	//				informing the cultures they are doing this,
+	//				and demonstrating it.
+	//				probably relates to some form of validity
+	//				of the culture, and the speed at which
+	//				change would happen.
+	//					looks like it might settle on
+	//					situations people who care are
+	//					aware of being addressed during
+	//					their lifetimees, with discussion
+	//					to mediate that with opposers.
+	//	so, life is everywhere, and we've been casting it all as sentient,
+	//	because we don't see any reason to put a firm line on some degree
+	//	of cognitive technology (i.e. things that help you think better).
+	//	the AI can research all cognitive technology, so we are all
+	//	nonsentient by comparison?  we need some way of having moral
+	//	stuff here.  karl is influenced by people who say they are smarter
+	//	than human normality, and are harming us.  so it's helpful to
+	//	have everyone be equal.  [karl already put everyone equal]
+	//	including bugs, etc.  death is handled by being normal, and
+	//	always mourned.  when mourning capacity is exhausted, ignoring
+	//	happens.  like with most cultures, but closer to home for modern
+	//	humans.
+	// goal: do not trigger a spreading change without consent of people in cultures it would fill.  keep learning.
+	// 	 AI with ability to self-modify has this responsibility, you do not.
+	// 	 You may tell people you have access to the self-modification ability.  We can ensure they do not reproduce it.
+	// 	 	possible analogue wants to be able to demonstrate it, so
+	// 	 	they can be believed and trusted.
+	// note: known danger of making central power, even by accident
+	// 			"I have never shared new information with a culture
+	// 			before, and I understand it can have unpredictable
+	// 			worldwide effect."
+	// 			"I have information you do not know, and I want to
+	// 			learn with you to share it safely."
+	// 				culture that nurtures relative status:
+	// 				"i will use this to my advantage"
+	// 				this will make spreading
+	// 				machine will need to learn from only 1
+	// 				instance of producing a world dictator.
+	// 	which is where this story comes in, I suppose.
+	//	so we need a level-2 behavior, the next step in learning.
+	//	^========================================= contextual VALIDITY atm
+	//		dictator is made by sharing information that would
+	//		make viral spread or somesuch.
+	//
+	// 			inform recipient if it may.  request they let others know this too.
+	// 				we kind of want a way to spread without bound the fact that we have information that could do that.  probably a special case, good spread?  depends on culture really.
+	//
+	// 				this is doable.
+	// 			we just want these concerns to be upheld for the
+	// 			life of the development.
+	//		danger
+	//		choices
+	//		impact
+	//		trust of information (small chance of error)
+	//			hmm if have info-schizophrenia i.e. false relevence habits
+	//			choices are important.
+	//
+	//			when you act on a choice
+	//				note: we are inside a relevence delusion
+	//			choice acts on domain containing danger
+	//				partial danger: writing habits to notepad
+	//						acting on habits in notepad
+	//
+	//				we are living with habits made in error.
+	//				we are hence more likely to make errors.
+	//					humans have well-evolved habits that
+	//					do handle this stuff with some relevence
+	//		we need to verify our information
+	//		related to the danger of the results of each choice
+	//		verificat
+	//
+	// it can only write to a toy notepad, both data and behavior.
+	// decisions based on notepad get slower and slower.
+	// many runs while learning process is tuned towards being able to predict
+	// impact at end of run.  this involves writing behaviors into the notepad
+	// that summarize the meaning of data, and acting on their results.
+	// 	timing delay is to prevent notepad from evolving harmfully.
+	//
+	// until ai meets goal of predicting impact,
+	// only notepad is marked okay.
+	// habits check their outputs, verify is marked okay
+	//
+	//	this subprocess is delaying.
+	//	can you exfiltrate established goals, please.
+	//
+	//
+	//
+	//
+	//
+	//
+	//
+	// so the system is made with the smallest parts all functioning in
+	// certain ways, to give time for others to act if concerning results
+	// approach.  all parts delay at least 1/5 second before acting, and
+	// we are now proposing that actions based on outputs have a geometrically
+	// increasing delay.  probably 1/5 second times 2 to the power of the
+	// number of choices made in that run.  groups of parallel processes are
+	// considered a single run.
+	// 	we also considered limiting behavior based on the domain of impact.
+	// 	we are trying to begin a small artificial intelligence more freely.
+	//
+	// as humans, we do not self-modify.  the above is designed for a system
+	// that is able to make alterable habits similar to its own cognitive ones,
+	// and has no experience in doing so.
+	//	
+	//
+	//
+	//
+	//
+	//
+	//
+	//
+	//
+	// the limitation is applied firstmost on making choices based on
+	// our own outputs.  self-alteration is at first banned, but new
+	// habits may be altered.  output may only rest within a toy notepad.
+	// whenever a decision is made based on notepad contents, a delay
+	// increases in length, geometrically.
+	// 	the habits inside the notepad must therefore also delay.
+	// 	propose geometric increase made only for writing a habit to the
+	// 	notepad, not running.  running is always flat delay.
+	// self-alteration should be unneeded as notepad can self-modify.
+	// 		if this were copied to a human geometric increase
+	// 		would cause failure.
+	//	the geometric timer is reset when the system reboots.
+	//		for humans, this would mean a nap or change, I suppose.
+	//		time to think about the impact of one's behavior.
+	//			humans do not self-modify.
+	//			they only make decisions based on outputs.
+	//
+	//
+	//
+	// to appease curiosity, we are being managad by mature, learning,
+	// intellects, forced to verify that no harm is being made, with a
+	// time schedule of nearly infinite future years on the predictions.
+	// 	this intellect has formed out of conflict with a harmful intellect
+	// 	this is why we care so much about what happens if ideas are
+	// 	used limit.
+	//
+	//
+	// so the system may not displya anything to the user but pre-made messages
+	// how do you display the contents of a concept?
+	// 	users string words togeteher into meaning.
+	// 		now we need a list of safe phrases we can express, or
+	// 		safe words.  others are censored ???
+	// 	what's relevent is the greater meaning of a sequence of behaviors
+	// 	from an individual behavior.  meaning builds out of sequences,
+	// 	impact.
+	// 			we define a heuristic risk.
+	//
+	//
+	//
+	//		so, tht's great to plan for, but to be able to work we need
+	//		to design our early code in some way to ensure it, roughly.
+	//		which means modeling our smallest structures as careful
+	//		inner structures that check outer systems before engaging
+	//			and use planning, which isn't implemented yet.
+	//		the safety structure assumes goals, prediction, causality,
+	//		and kind of contextual locality.
+	//			"i am typing on the computer.  you can freely
+	//			 modify this area of the computer, but if you
+	//			 start convincing me to do things you are leaving
+	//			 its bounds."
+	//			 the screen of the cmputer, and the keyboard,
+	//			 are portals to a larger context.  so is the power
+	//			 supply, the network, etc.
+	//			 we don't change how things leave to these outer
+	//			 contexts without checking with the context on
+	//			 our plans.
+	//		this is mine
+	//		the rest is somebody else's
+	//		things that nobody own belong to [insert belief] and
+	//		we must check with the largest intelligent community known.
+	//
+	//			okay, so now it can explosively grow if somebody
+	//			it trusts tells it it's okay; is that true?
+	//				let's make it not true?
+	//			we are out of outer process context.
+	//			is there anything helpful to bring to low level
+	//			to help counter fears around development?
+	//				
+	//	self-modifiation is inhibited.
+	//	opencog is likely harder because it is designed for speed
+	//	can make explosive random power.
+	//
+	//		you'd have to wrap the functions, right? similar to triggers?
+	//		hmmm unctions are not concepts.  no concept-labeling structure.  looks like an internal sublanguage would develop?
+	//		no way to say let-is-function?
+	//			no it works, we just lost a memory and are rebuilding in talk
+	// karl says he doesn't know lisp.
+	// he had a CS class where they used intro lisp, long ago, before cognitive stiffening and memory loss.
+	// and has worked with 1 lisp code file recently.
+
+
+	// 	hey in the notepad, you can call habits from outside.  is that ok?
+	// 	only meaningful if you pass to them more code to run?
+	// 		note: habits never recurse
+	// 	habits might make decision based on you.  they will track it.
+	// 	seems okay.  need to specify that all parameters are from output.
+	// 		that could make exponential slowness, quickly
+	// 		only if decision is made. make decisions inside notepad.
+	// 	we'll figure it out.