1. OVERVIEW AND BRAIN-MIND DIAGRAM
/^^^^^^^^^\ Rejuvenate Recycles Oldest Memories /^^^^^^^^^\
/ visual \ / ________ \
/ memory \ | | | | | | | | / / audSTM \ \
| _______ | | | | | + | | | | / "vault" \ |
| /old \ | | | | | | | + | | \__________/ |
| / image \---|-------+ | | | | | + |oldest memories|
| \ recog / | a|C|f| | | + | | |to be forgotten|
| \_______/ | b|O|i| + | | | | | |
| | s|N|b| | | | + | |newest memories|
| | t|C|e| | + | | | |to be recycled |
| | r|E|r| + | | | | |periodically by|
| | a|P|s| | | | | + |backwards shift|
| _______ | c|T| | | | + | | | ________ |
| /new \ | t|_|_|_ |_|_|_|_| | / \ |
| / percept \ | /Psi \-----/ English \---|-/ Auditory \ |
| \ engram /---|---/concepts\---/ lexicon \--|-\ phonemes / |
| \_______/ | \________/ \___________/ | \________/ |
diagrams.html shows a Theory of Mind.
The Rejuvenate module recycles the precious memory space of the
artificial Mind by "forgetting" (erasing) the oldest memories and
by periodically moving the main body of memory backwards by a set
amount of engram units so that the freshest and most recent memory
spaces of consciousness may become free to receive new engrams.
The rejuvenation process is like a pruning of what the AI thinks
about. Since the consciousness is filling up not only with input
from the external world but also with the reentry of thoughts
generated by the seed AI in communication with self or others,
the oldest memories have a chance to be saved from oblivion if
the associative process of thinking re-activates the old ideas
and brings them forward for fresh deposition in the consciousness.
2. REJUVENO ERGO SUM
Rejuvenate() as a module of Mind permits the AI to run endlessly.
On the one hand, the Rejuvenate function is not strictly a part of
the basic theory or algorithm for artificial intelligence, because
a natural human brain-mind operates with a fixed set of neurons and
is not given an opportunity to rejuvenate itself over and over.
On the other hand, artificial minds need some form of rejuvenation
if they are to live potentially forever, so Rejuvenate is not a
module of natural minds but is instead a module of artificial minds.
Although the JavaScript AI Mind contains the Rejuvenate module for
the purpose of teaching about it, there is no point in trying to run
the JS AI for more than, say, a single day of tutorial instruction or
of AI demonstration at an educational science fair or at a commercial
exposition where perhaps a sales force wants to demonstrate a free AI
that can interact with a potential purchaser, who instantly receives
a printed transcript of the historic occasion: meeting an AI Mind.
Mind.Forth AI for robots, however, is getting to the point where it may
be permitted to run on-screen from where the sun now stands forever.
The diagram ai4u_157.html is a flowchart of Mind.
// Rejuvenate() is called by Security() when the "cns" is almost full
// and makes the seed AI potentially immortal by erasing the
// oldest memories to free up "cns" space for new memories.
function Rejuvenate() { // ATM 2aug2002; or your ID & date.
edge = 0; // When found, edge-of-thought becomes "1".
rjc = (rjc+1); // Increment the Rejuvenation-counter "rjc".
// Warn users not to enter input during memory-recycling:
fyi=("<font color='red'>"+"Rejuvenating; please wait!"+"<\/font>");
Voice(); // Display the Voice:brain fyi message.
for (i = (vault+coda); i<(t+2); ++i) { // loop forwards to time "t".
jrt = (i - coda); // pass the engram "coda-units" backwards;
if (edge == 1) { // When edge "{" has been found
Psi[i].psiExam(); // break each Psi node into constituent parts;
Psi[jrt] = new psiNode(psi0,psi1,psi2,psi3,psi4,psi5,psi6);
Psi[i] = new psiNode(" ",0," "," "," "," "," "); // safety
} // end of normal procedure of moving Psi concept nodes backwards.
if (edge == 1) { // When edge "{" has been found
enLexicon[i].enExam(); // break En(glish) node into parts;
if (en5 > (vault+coda)) { // If "aud" is big enough...
en5 = (en5 - coda); // store "aud" after the "vault".
} // end of test
enLexicon[jrt] = new enNode(en0,en1,en2,en3,en4,en5);
enLexicon[i] = new enNode(" ",0," "," "," "," "); // safety
} // end of normal procedure of moving lexical engrams backwards.
if (edge == 1) { // When edge "{" has been found
audMemory[i].audExam(); // activate auditory engram nodes
audMemory[jrt] = new audNode(aud0,aud1,aud2,aud3,aud4,aud5);
audMemory[i] = new audNode(" ",0," "," "," "," ");
} // Once aud2 = "{" -- edge turns and remains true.
if (edge == 0) { // Until edge-of-thought is found
audMemory[i].audExam(); // float the pre-move pov "aud2" symbol
if (aud2 == "{") edge = true; // Switching to "edge"
// so that bracket "{" will show start of a whole thought.
audMemory[jrt] = new audNode(" ",0," "," "," "," ");
enLexicon[jrt] = new enNode(" ",0," "," "," "," ");
Psi[jrt] = new psiNode(" ",0," "," "," "," "," ");
} // end of assumption that earliest memory is incomplete.
} // end of backwards i-loop
t = jrt; // Final value of "junior time" becomes time "t".
for (j = t; j < cns; ++j) { // Blank out all rejuvenated time.
audMemory[j] = new audNode(" ",0," "," "," "," "); // safety
enLexicon[j] = new enNode(" ",0," "," "," "," "); // safety
Psi[j] = new psiNode(" ",0," "," "," "," "," "); // safety
} // End of the upper-coda blank-out.
} // End of Rejuvenate; return to Security().
\ REJUVENATE is called by SECURITY when the "cns" is almost full,
\ and makes the seed AI potentially immortal by erasing the
\ oldest memories to free up "cns" space for new memories.
: REJUVENATE \ ATM 4aug2002; or your ID & date.
0 edge ! \ When found, edge-of-thought becomes "1".
1 rjc +! \ Increment the Rejuvenation-counter "rjc".
CR ." Please wait as memories migrate in rejuvenation #" rjc @ . CR
t @ 2 + coda @ vault @ + DO \ Loop after "vault" and "coda"
\ Create a "junior-time" index offset by "coda":
I jrt ! \ First obtain the value of the current "Index".
jrt @ coda @ - jrt ! \ Then reduce the value by "coda" units.
edge @ 1 = IF
I 0 psi{ @ jrt @ 0 psi{ ! 0 I 0 psi{ ! \ Move the engram from
I 1 psi{ @ jrt @ 1 psi{ ! 0 I 1 psi{ ! \ its senior time-spot
I 2 psi{ @ jrt @ 2 psi{ ! 0 I 2 psi{ ! \ down to the "jrt"
I 3 psi{ @ jrt @ 3 psi{ ! 0 I 3 psi{ ! \ "junior-time" spot
I 4 psi{ @ jrt @ 4 psi{ ! 0 I 4 psi{ ! \ and erase the
I 5 psi{ @ jrt @ 5 psi{ ! 0 I 5 psi{ ! \ original engram.
I 6 psi{ @ jrt @ 6 psi{ ! 0 I 6 psi{ !
THEN
edge @ 1 = IF
en5 @ 1 < IF 0 en5 ! THEN \ Avoid negative "aud" flags.
I 0 en{ @ jrt @ 0 en{ ! 0 I 0 en{ ! \ After moving, erase.
I 1 en{ @ jrt @ 1 en{ ! 0 I 1 en{ !
I 2 en{ @ jrt @ 2 en{ ! 0 I 2 en{ !
I 3 en{ @ jrt @ 3 en{ ! 0 I 3 en{ !
I 4 en{ @ jrt @ 4 en{ ! 0 I 4 en{ !
I 5 en{ @ en5 ! \ Fetch the "aud" value to store as "en5"
en5 @ vault @ < IF \ If "aud" points into bootstrap vault
en5 @ jrt @ 5 en{ ! 0 I 5 en{ ! THEN \ unchanged "aud"
en5 @ coda @ vault @ + > IF \ If "aud" is big enough...
en5 @ coda @ - jrt @ 5 en{ ! \ store "aud" after vault.
THEN 0 I 5 en{ ! \ Erase original engram.
THEN
edge @ 1 = IF \ Although at first "edge" will be "0"
I 0 aud{ @ jrt @ 0 aud{ ! \ shift backwards
I 1 aud{ @ jrt @ 1 aud{ ! \ shift backwards
I 2 aud{ @ jrt @ 2 aud{ ! \ shift backwards
I 3 aud{ @ jrt @ 3 aud{ ! \ shift backwards
I 4 aud{ @ jrt @ 4 aud{ ! \ shift backwards
I 5 aud{ @ jrt @ 5 aud{ ! \ shift backwards
jrt @ 0 aud{ @ EMIT \ show the transfer
THEN
\ Searching for ASCII "123" bracket "{" inserted by SVO module:
edge @ 0 = IF \ As long as edge-of-thought has NOT been reached
32 jrt @ 0 aud{ ! \ Use a SPACE not a zero.
0 jrt @ 1 aud{ !
I 2 aud{ @ 123 = IF 1 edge ! THEN
0 jrt @ 2 aud{ !
0 jrt @ 3 aud{ !
0 jrt @ 4 aud{ !
0 jrt @ 5 aud{ !
0 jrt @ 0 en{ ! \ Store blank engrams after the enBoot vault
0 jrt @ 1 en{ ! \ until the "edge" bracket "{" is found that
0 jrt @ 2 en{ ! \ indicates the edge of a complete thought
0 jrt @ 3 en{ ! \ in auditory, semantic & conceptual memory
0 jrt @ 4 en{ ! \ about to be moved "coda" moments backwards
0 jrt @ 5 en{ ! \ and be redeposited in "junior time" memory.
0 jrt @ 0 psi{ ! \ "psi"
0 jrt @ 1 psi{ ! \ "act"
0 jrt @ 2 psi{ ! \ "jux"
0 jrt @ 3 psi{ ! \ "pre"
0 jrt @ 4 psi{ ! \ "pos"
0 jrt @ 5 psi{ ! \ "seq"
0 jrt @ 6 psi{ ! \ "enx"
THEN
LOOP
jrt @ t ! \ Final value of "junior time" becomes time "t".
\ t @ 40 - tov ! \ Experimental time-of-voice for .echo
cns @ t @ DO \ Blank out all rejuvenated time.
32 I 0 aud{ ! \ Use a SPACE not a zero.
0 I 1 aud{ !
0 I 2 aud{ !
0 I 3 aud{ !
0 I 4 aud{ !
0 I 5 aud{ !
0 I 0 en{ ! \ Blank out the "rejuvenated" most recent
0 I 1 en{ ! \ areas of the "enVocab" English vocabulary
0 I 2 en{ ! \ array, from the downsized time "t" point
0 I 3 en{ ! \ up to the highest "cns" value of time "t".
0 I 4 en{ !
0 I 5 en{ !
0 I 0 psi{ ! \ Blank out psi from "t" to end of "cns".
0 I 1 psi{ ! \ "act"
0 I 2 psi{ ! \ "jux" 22jul2002 forces other tags down.
0 I 3 psi{ ! \ "pre"
0 I 4 psi{ ! \ "pos"
0 I 5 psi{ ! \ "seq"
0 I 6 psi{ ! \ "enx"
LOOP \ End of blank-out of recovered recent memory space.
CR ." End of Rejuvenation #" rjc @ . CR
; \ End of Rejuvenate; return to the Security mind-module.
5. ANALYSIS OF THE MODUS OPERANDI
Since the JavaScript AI Mind currently contains three arrays of
psychological memory -- Psi, En(glish lexicon) and audMemory --
the Rejuvenate module must go into all three engram-arrays and
move the engrams back by a set amount or interval, expressed by
the value of the variable "coda" (from the Latin for "tail") above.
Not only must the memory engrams be moved backwards but the flags
connecting the semantic memory concepts must all be recalculated
so that the AI Mind still functions properly. As long as the
Rejuvenate process is done all at once and as quickly as possible,
it is a simple matter to move the entire Mind-full of data.
Accordingly the Rejuvenate process is invoked from the Security
module after the most recent generation of a thought by the AI Mind.
At the same time, a warning to users is flashed in red on the screen:
Rejuvenating; please wait!
-- to dissuade human users from entering
linguistic input that might interfere with the mass-transfer of data.
When a force in the universe (perhaps you) first brings the AI Mind
to life, the English bootstrap enBoot module transfers some elemental
memories from the program source code into the very first memory spaces.
Such bootstrap memories help to launch the mental activity of the AI
by illustrating various Chomskyan grammar structures and by providing
baseline psychological content for testing or therapy purposes on the
part of engineers or a new breed of mental health workers devoted to AI.
Because the bootstrap memories are so valuable, care is taken not to
overwrite the bootstrap area when all other memory engrams are shifted.
Alternatively, it would be possible simply to re-write the bootstrap,
but there is no incentive to do so unless self-modifying (autopoiesis)
code changes the bootstrap sequence or there is a question of corruption.
All open-source AI coders are free to decide this issue differently;
an advanced, robust AI may only once or never even need the bootstrap.
Of course, a good, solid bootstrap sequence may serve as food for
thought to keep the AI Mind from experiencing sensory deprivation.
As the bootstrap grows to include new syntactic grammar structure
and special knowledge of an expert nature for special-purpose AI,
the overall health of the Mind becomes steadier and more robust.
Various safety measures are taken in the Rejuvenate source code to
guard against pitfalls such as spurious memories appearing or the
corruption of memory-data in transit from recent to distant points.
It should be pointed out here to AI coders that the same coding mechanisms
that allow rejuvenation would also allow multiple robots or cyborgs to
share a common memory space in either a dream state or a waking state --
in other words, to achieve a true Vulcan mind-meld of
Star Trek fame.