Although an AI coder or Mind
Maintainer may wish to recreate the
pre-existing AI Minds thinking in
English
or
Latin
or
Russian,
one should not attempt to copy the entire codebase all at once,
because software bugs may occur in a new AI that becomes
devilishly difficult to debug without knowledge of the number
of bugs or of their location in the codebase. By replicating
an AI module by module, the AI coder not only keeps the code
relatively bug-free during AI-genesis, but also becomes
totally familiar with the crescent codebase by dint of
constant testing and troubleshooting.
Code the
MainLoop shown above in your chosen programming language.
Use either an actual loop with subroutine calls, or make a ringlet
of perhaps object-oriented module stubs, each calling the next stub.
Provide the ESCAPE key or other mechanisms for the user to stop the AI.
Below is an example of starting to code
mind.pl as the
Main AI Loop in
Perl, along with page-number references to the
fifth edition (2015) of the book
PERL by Example, by Ellie Quigley.
#!/usr/bin/perl
$IQ = 0; # PERL by Example (2015), p. 17
while ($IQ < 8) { # PERL by Example (2015), p. 190
print "IQ = $IQ Enter new IQ: ";
$IQ = <STDIN>; # PERL by Example (2015), p. 50
} # End of mind.pl program for coding Strong AI in Perl
Start a subroutine or module that is able to sense something
coming in from the outside world, i.e., a key-press on the keyboard.
In
Perl we will count on pressing Ctrl+C to halt the
AI Mind program if we need to rescue it from an infinite loop.
You may also create a numeric limit based on a
variable used
as a counter so that the program will halt when it reaches
your arbitrary limit. In languages other than Perl,
you may trap for special key-presses such as the following.
If possible, code recognition of the Escape-key (ASCII 27) for halting the AI.
Once the escape-code works within the
Sensorium stub, remove any
escape-code from the
MainLoop module.
Below is the expanded Perl code for AI Step #Two.
Notice that there is a "forward declaration" of the
Sensorium module whose actual code is then located
below the main loop that calls sensorium(). Within
the sensorium mind-module, you have the option, shown below,
of announcing that you are in the sensorium module by
stating so at the start of any on-screen prompt or other message
conveyed to the user from within the sensorium code.
As your coding moves beyond the sensorium module, you
may remove any such blatant indication that you are
in the sensorium module.
#!/usr/bin/perl
sub sensorium; # PERL by Example p. 351 Forward declaration
$IQ = 0; # PERL by Example (2015), p. 17
while ($IQ < 8) { # PERL by Example (2015), p. 190
sensorium(); # PERL by Example p. 350: () empty parameter list
} # End of main loop calling AI subroutines
sub sensorium() {
print "Sensorium: IQ = $IQ Enter new IQ: ";
$IQ = <STDIN>; # PERL by Example (2015), p. 50
} # End of mind.pl program for coding Strong AI in Perl
Now you have two modules or subroutines, a
MainLoop and a subordinate,
sensorium pathway. But what should come next in
AI evolution?
Now we need a reaction module, so that the organism may react
to its environment. Let's call the reaction-module "EnThink".
Now, of course, the simple organism is not truly thinking yet,
but in the
Perl AI code shown below we insert a think subroutine
and we adjust the previous code to accommodate the new
think mechanism.
#!/usr/bin/perl
use strict; # PERL by Example (2015), p. 77
use warnings; # PERL by Example (2015), p. 85
our $IQ = 0; # PERL by Example (2015), p. 689
sub sensorium; # PERL by Example p. 351 Forward declaration
sub think; # PERL by Example p. 351 Forward declaration
while ($IQ < 8) { # PERL by Example (2015), p. 190
sensorium(); # PERL by Example p. 350: () empty parameter list
think(); # PERL by Example p. 350: () empty parameter list
} # End of main loop calling AI subroutines
sub sensorium() { # Start sensory input.
print " Sensorium: Enter new IQ: ";
$IQ = <STDIN>; # PERL by Example (2015), p. 50
} # End of sensorium subroutine.
sub think() { # Start showing output as if generated by thinking.
print "Think: My IQ is now $IQ";
} # End of mind.pl program for coding Strong AI in Perl
use strict in a new line of code is a form of insurance
against bad coding practices, especially for a large program
such as an artificial intelligence.
use warnings in another new line of code is a technique
for being warned about any mistakes that you may make in
your Strong AI coding.
Adding the word our in the declaration of the our $IQ variable
is a way of making the variable global to the whole AI program and not
just to the Main Loop of the AI Mind.
We change the on-screen messages so that the sensorium()
subroutine now requests the analog of sensory input and the
think() subroutine makes the analog of a statement of thought.
You may experiment with changing the on-screen messages
to suit your own ideas of how an AI Mind should interact
with other sentient beings.
4. Initiate the
AudInput module for keyboard or acoustic input.
Drop any [ESCAPE] mechanism down by one tier, into the
AudInput module, but do not eliminate or bypass the quite essential
Sensorium module, because another programmer may wish to specialize
in implementing some elaborate sensory modality among your
sensory input stubs. Code the
AudInput module initially to deal
with ASCII keyboard input. If you are an expert at speech
recognition, extrapolate backwards from the storage requirements
(space and format) of the acoustic input of real phonemes in
your
AudInput system, so that the emerging robot Mind may be
ready in advance for the switch from hearing by keyboard to
hearing by microphone or artificial ear. Anticipate evolution
even beyond the Perl code shown below for auditory input.
#!/usr/bin/perl
use strict; # PERL by Example (2015), p. 77
use warnings; # PERL by Example (2015), p. 85
our $IQ = 0; # PERL by Example (2015), p. 689
sub AudInput; # PERL by Example p. 351 Forward declaration
sub sensorium; # PERL by Example p. 351 Forward declaration
sub think; # PERL by Example p. 351 Forward declaration
sub VisRecog; # PERL by Example p. 351 Forward declaration
while ($IQ < 8) { # PERL by Example (2015), p. 190
sensorium(); # PERL by Example p. 350: () empty parameter list
think(); # PERL by Example p. 350: () empty parameter list
} # End of main loop calling mind.pl Strong AI subroutines
sub sensorium() { # Start sensory input through sensory modalities.
print " Sensorium: Calling AudInput subroutine: \n";
AudInput(); # PERL by Example p. 350: () empty parameter list
# VisRecog(); -- non-existent subroutine is shown but commented out
} # End of sensorium subroutine in Perl artificial intelligence
sub AudInput() { # As if keyboard input were auditory hearing.
print " AudInput: Enter new IQ: ";
$IQ = <STDIN>; # PERL by Example (2015), p. 50
} # End of auditory input for human-computer interaction
sub think() { # Start showing output as if generated by thinking.
print "Think: My IQ is now $IQ";
} # http://ai.neocities.org/AiSteps.html
sub
VisRecog; has been added to the declarations of subroutines
in order to flesh out the sensorium code by showing that the
visual recognition module could be called if there was such a module available.
5. The TabulaRasa loop.
Before you can create an auditory memory
AudMem subroutine
for storing input from the keyboard, you may need to code a
"TabulaRasa" loop that will fill the mental memory of the
AI with blank engrams, thus reserving the memory space
and preventing error messages about unavailable locations
in the AI memory.
#!/usr/bin/perl
use strict; # PERL by Example (2015) p. 77
use warnings; # PERL by Example (2015) p. 85
our $cns = 32; # size of AI memory for central nervous system.
our $IQ = 0; # PERL by Example (2015) p. 689
our @aud = " "; # PERL by Example (2015) p. 17: auditory array
sub AudInput; # PERL by Example p. 351 Forward declaration
sub sensorium; # PERL by Example p. 351 Forward declaration
sub think; # PERL by Example p. 351 Forward declaration
sub VisRecog; # PERL by Example p. 351 Forward declaration
TabulaRasa: { # PERL by Example (2015), p. 204: Labels
my $trc = 0; # $trc variable is "tabula rasa counter".
print "Size of experiential memory is $cns \n"; # Increase as needed.
until ($trc == $cns) { # PERL by Example (2015), p. 193: "Loops".
$aud[$trc] = " "; # Fill CNS memory with blank spaces.
$trc++; # PERL by Example (2015) p. 21: autoincrement $trc.
} # End of loop filling auditory memory with blank engrams.
} # End of TabulaRasa "clean slate" sequence.
while ($IQ < 8) { # PERL by Example (2015), p. 190
sensorium(); # PERL by Example p. 350: () empty parameter list
think(); # PERL by Example p. 350: () empty parameter list
} # End of main loop calling mind.pl Strong AI subroutines
sub sensorium() { # Start sensory input through sensory modalities.
print " Sensorium: Calling AudInput subroutine: \n";
AudInput(); # PERL by Example p. 350: () empty parameter list
# VisRecog(); -- non-existent subroutine is shown but commented out
} # End of sensorium subroutine in Perl artificial intelligence
sub AudInput() { # As if keyboard input were auditory hearing.
print " AudInput: Enter new IQ: ";
$IQ = <STDIN>; # PERL by Example (2015), p. 50
} # End of auditory input for human-computer interaction
sub think() { # Start showing output as if generated by thinking.
print "Think: My IQ is now $IQ";
} # http://ai.neocities.org/AiSteps.html
The new variable
$cns
in the above code is set to
an arbitrary value by the designer or
AI Mind maintainer.
You start out with a low $cns value so that you may see
the entire contents of mental memory during the first
coding of mind-modules that store and retrieve engrams
of memory. As the AI grows larger and larger, the psychic
memory will become too big to see on-screen all at once,
but you may insert code for the purpose of printing out
the memory onto paper, or into a file separate from the AI.
Since an AI Mind is theoretically immortal and can have
a vast life-span, it will later be convenient and necessary
to recycle the mental $cns memory with a
ReJuvenate module.
The new @aud array for auditory memory will hold
individual keystrokes of human input or individual characters
from any file or website that the AI tries to read.
A more advanced AI will use acoustic phonemes instead of
alphabetic characters for auditory input and memory storage.
Characters are close enough to phonemes for coding the
prototype AI Minds.
6.
MindBoot (English +/- German +/- Russian bootstrap).
The knowledge base
(MindBoot)
module makes it possible for the Strong AI Mind to begin thinking
immediately when you launch the more advanced AI program. Here we
stub in the EnBoot subroutine with an English word or two before the
AudMem module begins to store new words coming from the
AudInput module. The EnBoot stub shows us that the first portion
of the AI mental memory is reserved for the innate concepts and
the English words that express each concept. If you use the
same Unicode that Perl enjoys to create a Strong AI Mind in
Arabic, Chinese, Hungarian, Indonesian, Japanese, Korean, Swahili,
Urdu or any other natural human language, you will need to create
a bootstrap module for your chosen human language. The English
Bootstrap shown in the Perl code below serves merely as an
example of how to do it.
#!/usr/bin/perl
use strict; # PERL by Example (2015) p. 77
use warnings; # PERL by Example (2015) p. 85
our $cns = 32; # size of AI memory for central nervous system.
our $IQ = 0; # PERL by Example (2015) p. 689
our @aud = " "; # PERL by Example (2015) p. 17: auditory array
our $t = 0; # Lifetime experiential time "$t"
sub AudInput; # PERL by Example p. 351 Forward declaration
sub sensorium; # PERL by Example p. 351 Forward declaration
sub think; # PERL by Example p. 351 Forward declaration
sub VisRecog; # PERL by Example p. 351 Forward declaration
TabulaRasa: { # PERL by Example (2015), p. 204: Labels
my $trc = 0; # $trc variable is "tabula rasa counter".
print "Size of experiential memory is $cns \n"; # Increase as needed.
until ($trc == $cns) { # PERL by Example (2015), p. 193: "Loops".
$aud[$trc] = " "; # Fill CNS memory with blank spaces.
$trc++; # PERL by Example (2015) p. 21: autoincrement $trc.
} # End of loop filling auditory memory with blank engrams.
} # End of TabulaRasa "clean slate" sequence.
EnBoot: { # http://mind.sourceforge.net/enboot.html
$t = 0; # English Bootstrap sequence stretches over mental time "$t".
print "English bootstrap is loading into memory... \n";
$t = 0; $aud[$t] = "H"; # Indexing of array begins with zero.
$t = 1; $aud[$t] = "E"; # Single elements of array use $aud not @aud.
$t = 2; $aud[$t] = "L"; # PERL by Example (2015), p. 95: Elements
$t = 3; $aud[$t] = "L"; # AudMem() stores new words at higher $t values.
$t = 4; $aud[$t] = "O"; # Bootstrap "HELLO" is not permanently here.
$t = 5; # A blank gap is necessary between words.
$t = 6; # More bootstrap words will be needed.
}; # http://code.google.com/p/mindforth/wiki/EnBoot
while ($IQ < 8) { # PERL by Example (2015), p. 190
sensorium(); # PERL by Example p. 350: () empty parameter list
think(); # PERL by Example p. 350: () empty parameter list
} # End of main loop calling mind.pl Strong AI subroutines
sub sensorium() { # Start sensory input through sensory modalities.
print " Sensorium: Calling AudInput subroutine: \n";
AudInput(); # PERL by Example p. 350: () empty parameter list
# VisRecog(); -- non-existent subroutine is shown but commented out
} # End of sensorium subroutine in Perl artificial intelligence
sub AudInput() { # As if keyboard input were auditory hearing.
print " AudInput: Enter new IQ: ";
$IQ = <STDIN>; # PERL by Example (2015), p. 50
} # End of auditory input for human-computer interaction
sub think() { # Start showing output as if generated by thinking.
print "Think: My IQ is now $IQ";
} # http://ai.neocities.org/AiSteps.html
The
$t
"time" variable is now declared not only as
a way to index through the memory arrays of the AI Mind,
but also as a measure or a counter of each mental moment
of time in the inner, psychic life of the artificial intelligence.
Time $t in the AI is not strictly coordinated with
real time in the external world or even with the internal
clock-time of the host computer. Time $t is a way of
scheduling and organizing discrete operations in the AI
software, such as accepting and storing new sensory input
and such as generating a sentence of thought by retrieving
time-bound phonemes from auditory memory and stringing them
together into an act of thinking that takes time to
utter and to communicate.
Into the @aud auditory array that was filled with
blank spaces by the TabulaRasa sequence and primed with
some bootstrap content by the EnBoot or
MindBoot sequence, insert some
new memories with the
AudMem auditory memory module.
Modify the
AudInput module to prompt for English
words and modify the
EnThink module to display words
stored in memory as if they were a thought being generated
in English (or in your chosen natural human language).
Below is the new
mind.pl Perl code with the changes that were made.
#!/usr/bin/perl
use strict; # PERL by Example (2015) p. 77
use warnings; # PERL by Example (2015) p. 85
our $age = 0; # Temporary age for loop-counting and loop-exit.
our @aud = " "; # PERL by Example (2015) p. 17: auditory array
our $cns = 32; # size of AI memory for central nervous system.
our $IQ = 0; # PERL by Example (2015) p. 689
our $msg = " "; # Variable holds a "message" of input from AudInput.
our $pho = ""; # $pho is for a "phoneme" or character of input.
our $t = 0; # Lifetime experiential time "$t"
our $t2s = 0; # auditory text-to-speech index for @aud array
sub AudInput; # PERL by Example p. 351 Forward declaration
sub sensorium; # PERL by Example p. 351 Forward declaration
sub think; # PERL by Example p. 351 Forward declaration
sub VisRecog; # PERL by Example p. 351 Forward declaration
TabulaRasa: { # PERL by Example (2015), p. 204: Labels
my $trc = 0; # $trc variable is "tabula rasa counter".
print "Size of experiential memory is $cns \n"; # Increase as needed.
until ($trc == $cns) { # PERL by Example (2015), p. 193: "Loops".
$aud[$trc] = " "; # Fill CNS memory with blank spaces.
$trc++; # PERL by Example (2015) p. 21: autoincrement $trc.
} # End of loop filling auditory memory with blank engrams.
} # End of TabulaRasa "clean slate" sequence.
EnBoot: { # http://mind.sourceforge.net/enboot.html
$t = 0; # English Bootstrap sequence stretches over mental time "$t".
print "English bootstrap is loading into memory... \n";
$t = 0; $aud[$t] = "H"; # Indexing of array begins with zero.
$t = 1; $aud[$t] = "E"; # Single elements of array use $aud not @aud.
$t = 2; $aud[$t] = "L"; # PERL by Example (2015), p. 95: Elements
$t = 3; $aud[$t] = "L"; # AudMem() stores new words at higher $t values.
$t = 4; $aud[$t] = "O"; # Bootstrap "HELLO" is not permanently here.
$t = 5; # A blank gap is necessary between words.
$t = 6; # More bootstrap words will be needed.
}; # http://code.google.com/p/mindforth/wiki/EnBoot
while ($t < $cns) { # PERL by Example (2015), p. 190
$age = $age + 1; # Increment $age variable with each loop.
print "\nMain loop cycle ", $age, " \n"; # Display loop-count.
sensorium(); # PERL by Example p. 350: () empty parameter list
think(); # PERL by Example p. 350: () empty parameter list
if ($age eq 999) { die "Perlmind dies when time = $t \n" }; # safety
} # End of main loop calling mind.pl Strong AI subroutines
sub sensorium() { # Start sensory input through sensory modalities.
print " Sensorium: Calling AudInput subroutine: \n";
AudInput(); # PERL by Example p. 350: () empty parameter list
# VisRecog(); -- non-existent subroutine is shown but commented out
} # End of sensorium subroutine in Perl artificial intelligence
sub AudInput() { # As if keyboard input were auditory hearing.
print "Enter a word of input, then press RETURN: ";
$msg = <STDIN>; # PERL by Example (2015), p. 50: Filehandle STDIN
print "AudInput: You entered the word: $msg";
AudMem(); # Calling the memory-insertion subroutine
} # End of auditory input for human-computer interaction
sub AudMem() { # http://mind.sourceforge.net/audstm.html
chop($msg); # PERL by Example (2015), p. 111: chop Function
my $reversed = reverse $msg; # PERL by Example (2015), p. 125: reverse
print "Input word reversed is: $reversed"; # PERL by Example, p. 125
do { # PERL by Example (2015), p. 194: do/until Loops
$pho = chop($reversed); # "chop" returns the chopped character as $pho.
print "\nAudMem: Storing ", $pho, " at time = ", "$t";
$aud[$t] = $pho; # Store the input phoneme in the auditory memory array.
$t++ ; # Increment time $t to store each input character separately.
} until $pho eq ""; # Store the whole word until $pho is empty.
$t++ ; # Add one more time point for a blank engram on-screen.
print "\n"; # Show a new-line gap on-screen.
} # http://code.google.com/p/mindforth/wiki/AudMem
sub think() { # Start showing output as if generated by thinking.
print "\nThink: "; # Display a new-line before "Think: "
$t2s = 0; # Speak all of $cns memory.
do { # PERL by Example (2015), p. 194: do/until Loops
print $aud[$t2s]; # Show each successive character in memory.
$t2s++ ; # Increment time-to-speech to advance thru memory.
} until $t2s eq $cns; # Show the whole array of AI Mind memory.
print "...comes from auditory memory. \n"; #
} # http://ai.neocities.org/AiSteps.html
The variable
$msg
holds the "message" typed in by the
human user during
AudInput.
The $pho
variable holds each character of keyboard input
as if it were an acoustic phoneme going into the @aud auditory
memory array. The prototype AI Minds use keyboard characters as if
they were phonemes of sound. Later on, more advanced forms of
artificial intelligence may use phonemes of actual speech
to store and retrieve words of natural human language.
Since Perl works with
Unicode for handling most written languages, it is now possible
to use these AI Steps and any suitable programming language to
code an AI that thinks in almost any natural human language.
The NewConcept module addresses the
symbol grounding problem by creating a new concept for any
unrecognized word in the input stream, even a misspelled word entered by mistake.
In Symbolic AI, each word of natural language is the symbol of a concept,
and as such is the key to accessing the concept. Of course, a recognized image
may also grant access to a concept.
The EnParser (English parser) module does not so much determine the
part of speech of a word of input, but more importantly it assigns to an input
word its grammatical role in the complete phrase being processed during
Natural Language Understanding.
The InStantiate module creates a new instance or node of a concept
in Symbolic AI when a word of input activates the concept. The created
instance is subject to change by the possibly delayed action of the
English EnParser or Latin LaParser or Russian RuParser module, because
Natural Language Understanding must often wait for the end of an idea
before the whole idea can be understood.
The AudRecog module for auditory recognition recognizes various forms
of a word, such as singular or plural nouns, or verbs with various
inflected endings.
The TacRecog module for tactile recognition in robots implements the haptic sense
for an AI Mind directly to touch and feel the external world. Even an AI Mind
not yet embodied in a physical robot may use TacRecog directly to sense and
feel a number-key pressed by the human user on a computer keyboard.
With philosophic implications for the learning of mathematics, an AI Mind
may directly sense numeric quantities through the numeric keys on the keyboard.
If the AudRecog module recognizes a particular word, then the
AudInput module calls the OldConcept module to create a new
instance of the previously known concept. If a word is not
recognized, AudInput calls the NewConcept module to create
a new concept for the word as a symbol.
The SpreadAct module for
Spreading Activation performs both simple spreading activation
between concepts and also an extremely sophisticated role of
responding to various input queries posed by human users.
The PsiDecay module lets the activation on "Psi" concepts decay gradually
over time, so that mind-modules which impose or spread activation may
operate more effectively and so that artificial
Consciousness may emerge as the seearchlight of attention shifts
from one highly activated concept or sensation to other highly activated
concepts or sensations.
The Speech module fetches characters from a starting point in
auditory memory and displays the characters on-screen until
a blank space occurs to signify the end of the word stored in memory.
The Indicative Mood module, as opposed to the
Imperative Mood module for
expressing commands, calls linguistically generative modules such as
EnNounPhrase and
EnVerbPhrase to express a thought indicating an idea or a belief.
The English verb-phrase module fetches from memory a verb that
has basically been pre-ordained to be expressed as the verb in
a Subject-Verb-Object (SVO) phrase or sentence. EnVerbPhrase also
calls a module like
EnVerbGen to generate an inflected form of
an indicated verb. EnVerbPhrase is designed with a view to calling the
VisRecog module to supply the English word for
the visually recognized object of the action of a verb,
such as in a sentence like "I see... (a dog)."
The English auxiliary-verb module calls auxiliary verbs such as
"do" or "does" for use in the generation of such sentences as a
negated idea, such as "God does not play dice."
The AskUser module works in conjunction with the logical InFerence module
to ask a human user to confirm or deny a logical inference being proposed
inside an AI Mind.
The ConJoin module inserts a conjunction during the generation of
a compound thought. For instance, if an AI Mind has two or more
higjly activated subjects of thought, the ConJoin module will
insert the conjunction "and" to join two active ideas together.
The OutBuffer module holds a word in a right-justified framework
where the ending of the word may be modified by a module like the
EnVerbGen module for generating a required English verb-form.
The InFerence module engages in
automated reasoning with logical inference.
For instance, if the user inputs 'John is a student," the AI may infer the
possibility that John reads books, The
AskUser module asks the user,
"Does John read books?" Depending on a "yes" or "no" answer, the
KbRetro module retroactively adjusts the knowledge base (KB),
either by discarding the unwarranted inference or by leaving intact
a true inference or inserting "not" into a negated inference such as
"John does not read books."
As soon as you have sensory memory for audition,
it is imperative to include motor memory for action.
The polarity of robot-to-world is about to become a
circularity of robot - motorium - world - sensorium - robot.
If you have been making robots longer than you have been
making minds, you now need to engrammatize whatever
motor software routines you may have written for your
particular automaton. You must decouple your legacy
motor output software from whatever mindless stimuli
were controlling the robot and you must now associate
each motor output routine with memory engram nodes
accreting over time onto a lifelong motor memory channel
for your mentally awakening robot. If you have not been
making robots, implement some simple motor output
function like emitting sounds or moving in four directions
across a real or virtual world.
35. Stub in the
Volition module for free will in autonomous robots.
In your robot software, de-link any direct connection
that you have hardcoded between a sensory stimulus
and a motor initiative. Force motor execution commands
to transit through your stubbed-in
Volition module, so that
future versions of your thought-bot will afford at least the
option of incorporating a sophisticated algorithm for free
will in robots. If you have no robot and you are building
a creature of pure reason, nevertheless include a
Volition stub for the sake of AI-Complete design patterns.
The
SeCurity module is not a natural component of the mind,
but rather a machine equivalent of the immune system in
a human body. When we have advanced AI robots running
factories to fabricate even more advanced AI robots,
let not the complaint arise that nobody bothered to
build in any security precautions. Stub in a SeCurity
module and let it be called from the
MainLoop by
uncommenting any commented-out mention of SeCurity
in the MainLoop code. Inside the new SeCurity module,
insert a call to
ReJuvenate but immediately comment-out
the call to the not-yet-existent ReJuvenate module. Also
insert into SeCurity any desired code or diagnostic messages
pertinent to security functions.
38. The HCI module in JavaScript manages human-computer interaction.
It is a simple matter to create a stub for the
TuringTest or HCI module
and to call it from within the
SeCurity module. Before the native
quickening of the
AI Mind, it may be necessary or at least advisable to
have the AI program come to a pause by default in the
TuringTest or HCI module so that the user must press the
Enter key for the AI to continue operating. If it
becomes obvious that the still rudimentary program
is pausing disruptively within any module other than
TuringTest, then it is time to remove the disruptive
code and to ensure that the budding AI stops looping
only once per cyclical calling of the TuringTest
InterFace.
If the AudListen or AudInput modules have only been stubbed
in and have not been fleshed out, it may be time now
to complete the full coding of AudListen, AudInput and
AudMem for storage of the input.
The Spawn module issues commands to the operating system to make copies
of an AI Mind that include experiential memories up to the point of
the spawning of each new AI Mind.
The module of
MetEmPsychosis or soul travel is designed to
spawn a remote copy of an AI Mind while immediately deleting the
previous version of the software and memories so that the remote
new version of the AI Mind is effectively the same AI traveling
across cyberspace in a metastatic process akin to mind uploading.
II. In a corner of the screenshot show yourself talking about the AiSteps sequence.
III. Upload the video to TikTok with a caption including all-important hash-tags
which will force governments and corporations to evaluate your work
because of FOMO -- Fear Of Missing Out:
#AI
#ИИ
#brain
#мозг
#ArtificialIntelligence
#ИскусственныйИнтеллект
#consciousness
#сознание
#Dushka
#Душка
#psychology
#психология
#subconscious
#подсознание
#AGI #AiMind #Alexa #ChatAGI #chatbot #ChatGPT #cognition #cyborg #Eureka #evolution
#FOMO #FreeWill #futurism #GOFAI #HAL #immortality #JAIC
#JavaScript #linguistics #metempsychosis #Mentifex #mindmaker #mindgrid
#ML #neuroscience #NLP #NLU #OpenAI #OpenCog #philosophy #robotics #Singularity #Siri #Skynet
#StrongAI #transhumanism #Turing #TuringTest #volition
Nota Bene: This webpage is subject to change without notice.
Any Netizen may copy, host or monetize this webpage to earn a stream of
income by means of an
affiliate program where the links to Amazon or other booksellers
have code embedded which generates a payment to the person whose link
brings a paying customer to the website of the bookseller.
This page was created by an
independent scholar in artificial intelligence
who created the following True AI Minds with sentience and with limited
consciousness.
563
Mentifex Autograph Postcards were mailed in 2022 primarily to
autograph collector customers at used bookstores to press the issue of
whether or not the Mentifex oeuvre and therefore the autograph is valuable.
These artwork-postcards with collectible stamps may be bought and sold at
various on-line venues.
