From c8bb547bea279af2bb48c13260f98aa8add07131 Mon Sep 17 00:00:00 2001
From: olpc user <olpc@xo-5d-f7-86.localdomain>
Date: Fri, 10 Jan 2020 14:55:19 -0800
Subject: move intellect-framework-from-internet into folder
---
.../starts/meaning-vm/habit-starts/common.hpp | 12 +
.../habit-starts/learn-to-dance-level-1.txt | 107 +++
.../meaning-vm/habit-starts/learning-parts.cpp | 347 +++++++++
.../meaning-vm/habit-starts/learning-parts.hpp | 41 +
.../starts/meaning-vm/habit-starts/rhythm.cpp | 126 +++
.../habit-starts/validity-impact-etc.txt | 859 +++++++++++++++++++++
6 files changed, 1492 insertions(+)
create mode 100644 intellect-framework-from-internet/starts/meaning-vm/habit-starts/common.hpp
create mode 100644 intellect-framework-from-internet/starts/meaning-vm/habit-starts/learn-to-dance-level-1.txt
create mode 100644 intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.cpp
create mode 100644 intellect-framework-from-internet/starts/meaning-vm/habit-starts/learning-parts.hpp
create mode 100644 intellect-framework-from-internet/starts/meaning-vm/habit-starts/rhythm.cpp
create mode 100644 intellect-framework-from-internet/starts/meaning-vm/habit-starts/validity-impact-etc.txt
(limited to 'intellect-framework-from-internet/starts/meaning-vm/habit-starts')
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.
--
cgit v1.2.3