Steps for Coding AI Minds with Natural Language Understanding

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.


1. Code the MainLoop module.
  /^^^^^^^^^^^\                                    Motor Output
 /   EYE       \            _________________     /YYYYYYYYYYYY\
|               |CONCEPTS  /                 \   | | ||| ||| || |
|   _______     |   | | | /     MainLoop      \  | | ||| ||| || |
|  / old   \    |   | | | \___________________/  | | ||| ||| || |
| /  dog    \!!!|!!!|!|!|   |    | | |    |      | |S||| ||| || |
| \ recog   /---|---|-|-+ __V___ | | |  __V___   | |H||| ||| || |
|  \_______/    |  p| | |(Tabula)| } | /      \  | |A|||R|||P|| |
|               |  e| | | \Rasa/ | | |(Volition) | |K|||U|||E|| |
|               |  r| | |  \__/  | | | \______/\ | |E|||N|||T|| |
|               |  s| |d|   _____| | |   |   |  \| |?|||?|||?|| |
|   visual      |  o| |o|  |     | | |  _V   |   \ | ||| ||| || |
|               |  n| |g|  |Mind-| | | /  \  |   |\  ________   |
|   memory      |  s| |s|  |Boot | | |/Emo-\ |   | \/        \  |
|               |   |f| |  |_____| | |\tion/ |   | ( Motorium ) |
|   channel     |   |e| | _________V | \__/  |   |  \________/  |
|               |   |a| |/          \|  _____V_  | |||||||||||| |
|               |   |r| |\ReJuvenate/| (EnThink) | |||||||||||| |
|   _______     |   | | | \________/ |  \_____/  | |||||||||||| |
|  /new    \    |   |_|_|      ______V__         | |||||||||||| |
| / percept \   |  /     \    /         \        | |||||||||||| |
| \ engram  /---|-(  Psy  )--( Sensorium )       | |||||||||||| |
|  \_______/    |  \_____/    \_________/        | |||||||||||| |


            ___________                    ___________           
           /           \                  /           \          
          /  Motorium   \                /  MindBoot   \         
          \_____________/     ______    /\_____________/
       __________   /|\      /      \  /         ____________
      /          \   |      /        \/         /            \
     (  EnThink   )  |     < MainLoop >--------(  ReJuvenate  )
      \__________/   |     /\        /\         \____________/
           __|_______|__  /  \______/  \  _____________
          /             \/              \/             \
          \  Volition   /                \  Sensorium  /
           \___________/                  \___________/

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


2. Code the Sensorium module or subroutine.

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.

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".


3. Stub in the EnThink module or DeThink module or RuThink module.

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.


7. AudMem (Auditory Memory).


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.


8. NewConcept.

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.


9. EnParser.

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.


10. InStantiate.

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.


11. AudRecog.

The AudRecog module for auditory recognition recognizes various forms of a word, such as singular or plural nouns, or verbs with various inflected endings.


12. TacRecog.

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.


13. OldConcept.

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.


14. SpreadAct.

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.


15. PsiDecay.

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.


16. Speech.

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.


17. Indicative.

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.


18. EnNounPhrase.

The English noun-phrase module selects the most activated noun-concept to be the subject of a phrase or sentence.


19. ReEntry.

The ReEntry module is used in the various JavaScript Minds to facilitate the reentry of an output word back into the AI Mind.


20. EnVerbPhrase.

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)."


21. EnAuxVerb.

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."


22. AskUser.

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.


23. ConJoin.

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.


24. EnArticle.

The English article module inserts the article "a" or the article "the" before a noun in a sentence being generated.


25. EnAdjective.

The English adjective module recalls and inserts an adjective during the generation of a thought.


26. EnPronoun.

The English pronoun module replaces a noun with a pronoun.


27. AudBuffer.

The auditory buffer module stores a word in memory for transfer to the OutBuffer module for inflectional processing.


28. OutBuffer.

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.


29. KbRetro.

The KbRetro module retroactively adjusts the knowledge base (KB) of the AI in response to user input responding to a question from the AskUser module.


30. EnNounGen. (not yet coded)

The English noun-generating module shall modify a singular English noun into its proper plural form by adding "s" or "es".


31. EnVerbGen or RuVerbGen.

The verb-generation module operates when the verb-phrase module fails to find a needed verb-form in auditory memory.


32. InFerence

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."


33. EnThink.

The English thinking module calls such subordinate modules as the Indicative module for a declarative sentence or the InFerence module for automated reasoning.


34. Motorium (Motor Memory).

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.


36. Imperative.

The Imperative Mood module, called by the free-will Volition module, issues commands such as "Teach me something" to the human user.


37. The SeCurity module.

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.


39. Spawn.

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.


40. MetEmPsychosis.

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.


...to be continued.

See also

http://mind.sourceforge.net/aisteps.html


AiTree of Ghost AI Mind-Modules
[Your AI Lab may print out all documentation pages into a notebook.]


You may discuss the Perl programming language at:
https://groups.google.com/group/comp.lang.perl.misc
http://stackoverflow.com/questions/tagged/perl
http://old.reddit.com/r/perl

You may discuss the Perl artificial intelligence at:
https://groups.google.com/group/comp.ai.nat-lang
http://stackoverflow.com/questions/tagged/artificial-intelligence
http://old.reddit.com/r/artificial

You may discuss Perl and AI combined at
http://lists.perl.org/list/perl-ai.html
http://www.nntp.perl.org/group/perl.ai/
http://www.mail-archive.com/perl-ai@perl.org


Strong AI software resulting from the above AI Steps:
MindForth in English;
Wotan in German;
Ghost in English;
Mens Latina in Latin;
Dushka in Russian.

http://www.google.com/patents/US8620890 is a patent that cites Mentifex MindForth.

The original thirty-four mind-modules are described in the AI4U book which was originally published in 2002. Artificial Intelligence in German was published in English in 2013 with an updated description of how all the AI Minds in German, English and Russian generate thoughts and perform automated reasoning with inference.

Meanwhile, the software names of the mind-modules have changed to a format compatible with the wiki-pages of the MindForth project on Google code. For example, the InFerence module is spelled with two uppercase letters in it so that any occurrence of the word InFerence is clickable on a wiki-page. The AI software in Forth or JavaScript does not care if the modules are named in wiki-format, so the module names were changed not only on the documentation pages, but also inside the free, open-source software for artificial intelligence.

The Amazon Kindle e-book InFerence (Artificial Intelligence) gives the mind-module source code with line-by-line explanation of how the AI implements automated reasoning with inference.

The contents of this page are subject to change without notice



Paperback book on AI in ancient Latin

Artificial Intelligence in Ancient Latin -- is available from Amazon in various countries:
Canada - France - Germany - Italy - Japan - Spain - United Kingdom - United States.
Ada's Technical Books
425 15th Avenue East
Seattle, WA 98122
USA Tel. 206-322-1058


Website Counter