Merge pull request #35 from opennars/MoreAtomsSupport

Update: Variable, Narsese, Config: Allow and use short for atoms inst…

README.md

@@ -46,7 +46,7 @@ Narsese:
 ./NAR shell < ./examples/nal/example1.nal
 ```
 
-English: (will be updated to Python3 at some point as well...)
+English: (needs NLTK v3.4.5, will be updated to Python3 at some point as well...)
 
 ```
 python2 english_shell.py < ./examples/english/story1.english

examples/nal/school.nal

@@ -104,5 +104,5 @@
 <<clock --> [large]> =/> <floor --> [?what]>>?
 //expected: Answer: <<clock --> [large]> =/> <floor --> [red]>>. Truth: frequency=0.964794, confidence=0.449068
 //If you are where the floor is red, where do you need to go to see a cyan floor?
-<(<floor --> [red]> &/ <({SELF} * ?2) --> ^go>) =/> <floor --> [cyan]>>?
+<(<floor --> [red]> &/ <({SELF} * ?where) --> ^go>) =/> <floor --> [cyan]>>?
 //expected: Answer: <(<floor --> [red]> &/ <({SELF} * kitchen) --> ^go>) =/> <floor --> [cyan]>>. Truth: frequency=1.000000, confidence=0.01029

src/Config.h

@@ -93,9 +93,9 @@
 //Maximum compound term size
 #define COMPOUND_TERM_SIZE_MAX 64
 //Max. amount of atomic terms, must be <= 2^(sizeof(Atom)*8)
-#define TERMS_MAX 256
+#define TERMS_MAX 65536
 //The type of an atom
-#define Atom unsigned char
+#define Atom unsigned short
 //Maximum size of atomic terms in terms of characters
 #define ATOMIC_TERM_LEN_MAX 30
 //Maximum size of Narsese input in terms of characters

src/Globals.h

@@ -55,5 +55,7 @@
 void assert(bool b, char* message);
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
+//Number of elements of compile time allocated array:
+#define NUM_ELEMENTS(array) (sizeof(array)/sizeof(array[0]))
 
 #endif

src/NAL.c

@@ -71,7 +71,7 @@ static void NAL_GenerateConclusionTerm(char *premise1, char *premise2, char* con
     //skip double/single premise rule if single/double premise
     if(doublePremise) { printf("if(!doublePremise) { goto RULE_%d; }\n", ruleID); }
     if(!doublePremise) { printf("if(doublePremise) { goto RULE_%d; }\n", ruleID); }
-    puts("Term substitutions[TERMS_MAX] = {0}; Term subtree = {0};");
+    puts("Term substitutions[27+NUM_ELEMENTS(Narsese_RuleTableVars)] = {0}; Term subtree = {0};"); //27 because of 9 indep, 9 dep, 9 query vars
     for(int i=0; i<COMPOUND_TERM_SIZE_MAX; i++)
     {
         NAL_GeneratePremisesUnifier(i, term1.atoms[i], 1);

src/Narsese.c

@@ -32,7 +32,7 @@
 //whether the package is initialized
 static bool initialized = false;
 //SELF atom, avoids strcmp for checking operator format
-Atom SELF; 
+Atom SELF;
 
 //Replace copulas with canonical single-char copulas, including sets and set elements!
 char* replaceWithCanonicalCopulas(char *narsese, int n)
@@ -228,13 +228,12 @@ int skipCompound(char** tokens, int i, int nt)
     return i;
 }
 
-static char* canonical_copulas = "@*&|;:=$'\"/\\.-%#~+!";
 char** Narsese_PrefixTransform(char* narsese_expanded)
 {
     static char* tokens[NARSESE_LEN_MAX+1]; //there cannot be more tokens than chars
     memset(tokens, 0, (NARSESE_LEN_MAX+1)*sizeof(char*)); //and last one stays NULL for sure
     char* token = strtok(narsese_expanded, " ");
-    int nt=0, nc = strlen(canonical_copulas);
+    int nt = 0, nc = NUM_ELEMENTS(Naresese_CanonicalCopulas) - 1;
     while(token)
     {
         tokens[nt] = token;
@@ -247,7 +246,7 @@ char** Narsese_PrefixTransform(char* narsese_expanded)
         {
             for(int k=0; k<nc; k++)
             {
-                if(tokens[i+1][0]==(int)canonical_copulas[k] && tokens[i+1][1] == 0)
+                if(tokens[i+1][0] == (int) Naresese_CanonicalCopulas[k] && tokens[i+1][1] == 0)
                 {
                     goto Continue;
                 }
@@ -360,11 +359,13 @@ void buildBinaryTree(Term *bintree, char** tokens_prefix, int i1, int tree_index
 Term Narsese_Term(char *narsese)
 {
     assert(initialized, "Narsese not initialized, call Narsese_INIT first!");
+    //parse Narsese by expanding it, bringing into prefix form, then building a binary tree, and normalizing variables
     Term ret = {0};
     char *narsese_expanded = Narsese_Expand(narsese);
     char** tokens_prefix = Narsese_PrefixTransform(narsese_expanded);
     int nt = 0; for(;tokens_prefix[nt] != NULL; nt++){}
     buildBinaryTree(&ret, tokens_prefix, 0, 1, nt);
+    Variable_Normalize(&ret);
     return ret;
 }
 
@@ -573,16 +574,31 @@ void Narsese_INIT()
     {
         memset(&Narsese_operatorNames[i], 0, ATOMIC_TERM_LEN_MAX);
     }
-    //index the copulas at first, to make sure these will have same index on next run
-    for(int i=0; i<(int) strlen(canonical_copulas); i++)
+    //index variables at first, these atoms come first as also used by Substitution struct
+    for(int i=1; i<=9; i++)
     {
-        char cop[2] = {canonical_copulas[i], 0};
+        char dep_varname[3] = "#1";
+        char indep_varname[3] = "$1";
+        char query_varname[3] = "?1";
+        query_varname[1] = indep_varname[1] = dep_varname[1] = (char) ('0' + i);
+        Narsese_AtomicTerm(dep_varname);
+        Narsese_AtomicTerm(indep_varname);
+        Narsese_AtomicTerm(query_varname);
+    }
+    //index rule table variables next:
+    for(unsigned int i=0; i<NUM_ELEMENTS(Narsese_RuleTableVars)-1; i++)
+    {
+        char varname[2] = " ";
+        varname[0] = Narsese_RuleTableVars[i];
+        Narsese_AtomicTerm(varname);
+    }
+    //index the copulas as well, to make sure these will have same index on next run
+    for(int i=0; i<(int)strlen(Naresese_CanonicalCopulas); i++)
+    {
+        char cop[2] = { Naresese_CanonicalCopulas[i], 0 };
         Narsese_AtomicTermIndex(cop);
     }
     SELF = Narsese_AtomicTermIndex("SELF");
-    Narsese_AtomicTermIndex("$1");
-    Narsese_AtomicTermIndex("$2");
-    Narsese_AtomicTermIndex("#1");
     initialized = true;
 }
 
@@ -638,7 +654,8 @@ Term Narsese_GetPreconditionWithoutOp(Term *precondition)
 
 bool Narsese_IsNonCopulaAtom(Atom atom)
 {
-    return (Narsese_atomNames[(int) atom - 1][0] >= 'a' && Narsese_atomNames[(int) atom - 1][0] <= 'z') ||
-           (Narsese_atomNames[(int) atom - 1][0] >= 'A' && Narsese_atomNames[(int) atom - 1][0] <= 'Z') ||
-           (Narsese_atomNames[(int) atom - 1][0] >= '0' && Narsese_atomNames[(int) atom - 1][0] <= '9');
+    return atom > 0 &&
+           ((Narsese_atomNames[(int) atom - 1][0] >= 'a' && Narsese_atomNames[(int) atom - 1][0] <= 'z') ||
+            (Narsese_atomNames[(int) atom - 1][0] >= 'A' && Narsese_atomNames[(int) atom - 1][0] <= 'Z') ||
+            (Narsese_atomNames[(int) atom - 1][0] >= '0' && Narsese_atomNames[(int) atom - 1][0] <= '9'));
 }

src/Narsese.h

@@ -44,6 +44,8 @@
 char Narsese_atomNames[TERMS_MAX][ATOMIC_TERM_LEN_MAX];
 char Narsese_operatorNames[OPERATIONS_MAX][ATOMIC_TERM_LEN_MAX];
 extern Atom SELF;
+#define Narsese_RuleTableVars "ABCMRSPXYZ"
+#define Naresese_CanonicalCopulas "@*&|;:=$'\"/\\.-%#~+!"
 
 //Methods//
 //-------//

src/Variable.c

@@ -67,6 +67,7 @@ Substitution Variable_Unify(Term *general, Term *specific)
         {
             if(Variable_isVariable(general_atom))
             {
+                assert(general_atom <= 27, "Variable_Unify: Problematic variable encountered, only $1-$9, #1-#9 and ?1-?9 are allowed!");
                 Term subtree = Term_ExtractSubterm(specific, i);
                 if(Variable_isQueryVariable(general_atom) && Variable_isVariable(subtree.atoms[0])) //not valid to substitute a variable for a question var
                 {
@@ -98,7 +99,9 @@ Term Variable_ApplySubstitute(Term general, Substitution substitution, bool *suc
     for(int i=0; i<COMPOUND_TERM_SIZE_MAX; i++)
     {
         Atom general_atom = general.atoms[i];
-        if(substitution.map[(int) general_atom].atoms[0] != 0)
+        bool is_variable = Variable_isVariable(general_atom);
+        assert(!is_variable || general_atom <= 27, "Variable_ApplySubstitute: Problematic variable encountered, only $1-$9, #1-#9 and ?1-?9 are allowed!");
+        if(is_variable && substitution.map[(int) general_atom].atoms[0] != 0)
         {
             if(!Term_OverrideSubterm(&general, i, &substitution.map[(int) general_atom]))
             {
@@ -118,7 +121,8 @@ static void countExtensionTerms(Term *cur_inheritance, int *appearing)
         Term subject = Term_ExtractSubterm(cur_inheritance, 1);
         for(int i=0; i<COMPOUND_TERM_SIZE_MAX; i++)
         {
-            if(Narsese_IsNonCopulaAtom(subject.atoms[i]))
+            Atom atom = subject.atoms[i];
+            if(Narsese_IsNonCopulaAtom(atom))
             {
                 appearing[(int) subject.atoms[i]] += 1;
             }
@@ -153,33 +157,74 @@ Term IntroduceImplicationVariables(Term implication, bool *success)
         left_side = Term_ExtractSubterm(&left_side, 1);
     }
     countExtensionTerms(&left_side, appearing);
-    Substitution subs = { .success = true };
-    int depvar_i = 1;
-    int indepvar_i = 1;
-    bool already_handled[TERMS_MAX] = {0};
+    char depvar_i = 1;
+    char indepvar_i = 1;
+    char variable_id[TERMS_MAX] = {0};
+    Term implication_copy = implication;
     for(int i=0; i<COMPOUND_TERM_SIZE_MAX; i++)
     {
-        Atom atom = implication.atoms[i];
-        if(!already_handled[(int) atom] && appearing[(int) atom] > 1)
+        Atom atom = implication_copy.atoms[i];
+        if(appearing[(int) atom] > 1)
         {
             if(right_contains[(int) atom])
             {
-                assert(indepvar_i <= 9, "More than 9 variables being introduced? That's not supported.");
-                char varname[3] = "$1";
-                varname[1] = (char) ('0' + indepvar_i);
-                subs.map[(int) atom] = Narsese_AtomicTerm(varname);
-                indepvar_i++;
+                int var_id = variable_id[(int) atom] = variable_id[(int) atom] ? variable_id[(int) atom] : indepvar_i++;
+                if(var_id <= 9) //can only introduce up to 9 variables
+                {
+                    char varname[3] = { '$', ('0' + var_id), 0 }; //$i
+                    Term varterm = Narsese_AtomicTerm(varname);
+                    if(!Term_OverrideSubterm(&implication, i, &varterm))
+                    {
+                        *success = false;
+                        return implication;
+                    }
+                }
             }
             else
             {
-                assert(depvar_i <= 9, "More than 9 variables being introduced? That's not supported.");
-                char varname[3] = "#1";
-                varname[1] = (char) ('0' + depvar_i);
-                subs.map[(int) atom] = Narsese_AtomicTerm(varname);
-                depvar_i++;
+                int var_id = variable_id[(int) atom] = variable_id[(int) atom] ? variable_id[(int) atom] : depvar_i++;
+                if(var_id <= 9) //can only introduce up to 9 variables
+                {
+                    char varname[3] = { '#', ('0' + var_id), 0 }; //#i
+                    Term varterm = Narsese_AtomicTerm(varname);
+                    if(!Term_OverrideSubterm(&implication, i, &varterm))
+                    {
+                        *success = false;
+                        return implication;
+                    }
+                }
+            }
+        }
+
+    }
+    *success = true;
+    return implication;
+}
+
+void Variable_Normalize(Term *term)
+{
+    int independent_i = 1, dependent_i = 1, query_i = 1;
+    bool normalized[COMPOUND_TERM_SIZE_MAX] = {0};
+    //replace variables with numeric representation, then return the term
+    for(int j=0; j<COMPOUND_TERM_SIZE_MAX; j++)
+    {
+        Atom atom = term->atoms[j];
+        char varType = Variable_isIndependentVariable(atom)  ? '$' :            (Variable_isDependentVariable(atom) ? '#' :          '?');
+        int *varIndex = Variable_isIndependentVariable(atom) ? &independent_i : (Variable_isDependentVariable(atom) ? &dependent_i : &query_i);
+        if(!normalized[j] && Variable_isVariable(atom))
+        {
+            assert(*varIndex<=9, "Variable overflow in variable normalization!");
+            char varname[3] = { varType, ('0' + *varIndex), 0 }; //$i, #j, ?k
+            (*varIndex)++;
+            for(int k=j; k<COMPOUND_TERM_SIZE_MAX; k++)
+            {
+                Atom atom2 = term->atoms[k];
+                if(atom == atom2)
+                {
+                    term->atoms[k] = Narsese_AtomicTermIndex(varname);
+                    normalized[k] = true;
+                }
             }
         }
-        already_handled[(int) atom] = true;
     }
-    return Variable_ApplySubstitute(implication, subs, success);
 }

src/Variable.h

@@ -38,19 +38,29 @@
 //--------------//
 //Substitution, mapping variable atoms to terms
 typedef struct {
-    Term map[TERMS_MAX];
+    Term map[27+1]; //there can only be 27 variables: $1 to $9 and #1 to #9 and ?1 to ?9, but it can't be 0
     bool success;
 } Substitution;
 
 //Methods//
 //-------//
+//Whether the atom is an independent variable, $i
 bool Variable_isIndependentVariable(Atom atom);
+//Whether the atom is a dependent variable, #1
 bool Variable_isDependentVariable(Atom atom);
+//Whether the atom is a query variable, ?1
 bool Variable_isQueryVariable(Atom atom);
+//Whether the atom is any variable
 bool Variable_isVariable(Atom atom);
+//Whether the term has variables of certain kind
 bool Variable_hasVariable(Term *term, bool independent, bool dependent, bool query);
+//Unify two terms, returning the substitution/unifier
 Substitution Variable_Unify(Term *general, Term *specific);
+//Applying the substitution to a term, returning success
 Term Variable_ApplySubstitute(Term term, Substitution substitution, bool *success);
+//Introduce variables in an implications
 Term IntroduceImplicationVariables(Term implication, bool *success);
+//Normalize variables, transforming ?what to ?1 for instance.
+void Variable_Normalize(Term *term);
 
 #endif