occam-verify-cli 1.0.388 → 1.0.404

package/src/{substitutions.js → ontology/substitutions.js}

@@ -2,11 +2,12 @@
 
 import { arrayUtilities } from "necessary";
 
-import { EMPTY_STRING } from "./constants";
+import { define } from "../ontology";
+import { EMPTY_STRING } from "../constants";
 
 const { find, first, clear, prune, filter, compress, correlate } = arrayUtilities;
 
-export default class Substitutions {
+export default define(class Substitutions {
   constructor(array, savedArray) {
     this.array = array;
     this.savedArray = savedArray;
@@ -22,18 +23,6 @@ export default class Substitutions {
 
   getLength() { return this.array.length; }
 
-  getFirstSubstitution() {
-    let firstSubstitution = null;
-
-    const length = this.getLength();
-
-    if (length > 0) {
-      firstSubstitution = first(this.array);
-    }
-
-    return firstSubstitution;
-  }
-
   getMetavariables() {
     const metavariables = [];
 
@@ -70,6 +59,18 @@ export default class Substitutions {
     return nonTrivialLength;
   }
 
+  getFirstSubstitution() {
+    let firstSubstitution = null;
+
+    const length = this.getLength();
+
+    if (length > 0) {
+      firstSubstitution = first(this.array);
+    }
+
+    return firstSubstitution;
+  }
+
   mapSubstitution(callback) { return this.array.map(callback); }
 
   findSubstitution(callback) { return this.array.find(callback) || null; }  ///
@@ -107,7 +108,7 @@ export default class Substitutions {
 
   findSubstitutionsByMetavariable(metavariable) {
     const substitutions = this.findSubstitutions((substitution) => {
-      const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualTo(metavariable);
+      const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualToMetavariable(metavariable);
 
       if (substitutionMetavariableEqualToMetavariable) {
         return true;
@@ -123,7 +124,7 @@ export default class Substitutions {
 
       if (substitutionSimple) {
         const simpleSubstitution = substitution,  ///
-              simpleSubstitutionMetavariableEqualToMetavariable = simpleSubstitution.isMetavariableEqualTo(metavariable);
+              simpleSubstitutionMetavariableEqualToMetavariable = simpleSubstitution.isMetavariableEqualToMetavariable(metavariable);
 
         if (simpleSubstitutionMetavariableEqualToMetavariable) {
           return true;
@@ -140,7 +141,7 @@ export default class Substitutions {
 
       if (substitutionComplex) {
         const complexSubstitution = substitution, ///
-              complexSubstitutionMetavariableEqualToMetavariable = complexSubstitution.isMetavariableEqualTo(metavariable);
+              complexSubstitutionMetavariableEqualToMetavariable = complexSubstitution.isMetavariableEqualToMetavariable(metavariable);
 
         if (complexSubstitutionMetavariableEqualToMetavariable) {
           return true;
@@ -155,11 +156,11 @@ export default class Substitutions {
     const substitutionA = substitution; ///
 
     substitution = this.findSubstitution((substitution) => {  ///
-      const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualTo(metavariable);
+      const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualToMetavariable(metavariable);
 
       if (substitutionMetavariableEqualToMetavariable) {
         const substitutionB = substitution, ///
-              substitutionBSubstitutionEqualToSubstitutionA = substitutionB.isSubstitutionEqualTo(substitutionA);
+              substitutionBSubstitutionEqualToSubstitutionA = substitutionB.isSubstitutionEqualToSubstitution(substitutionA);
 
         if (substitutionBSubstitutionEqualToSubstitutionA) {
           return true;
@@ -192,15 +193,15 @@ export default class Substitutions {
     return substitutionPresent;
   }
 
-  addSubstitution(substitution, specificContext) {
+  addSubstitution(substitution, context) {
     this.array.push(substitution);
 
     const substitutionString = substitution.getString();
 
-    specificContext.trace(`Added the ${substitutionString} substitution.`);
+    context.trace(`Added the ${substitutionString} substitution.`);
   }
 
-  removeSubstitution(substitution, specificContext) {
+  removeSubstitution(substitution, context) {
     const substitutionA = substitution; ///
 
     prune(this.array, (substitution) => {
@@ -213,7 +214,7 @@ export default class Substitutions {
 
     const substitutionString = substitution.getString();
 
-    specificContext.trace(`Removed the ${substitutionString} substitution.`);
+    context.trace(`Removed the ${substitutionString} substitution.`);
   }
 
   correlateSubstitutions(substitutions) {
@@ -247,7 +248,7 @@ export default class Substitutions {
     this.savedArray = null;
   }
 
-  resolve(generalContext, specificContext) {
+  resolve(context) {
     const metavariables = this.getMetavariables();
 
     metavariables.forEach((metavariable) => {
@@ -261,7 +262,7 @@ export default class Substitutions {
               resolved = substitution.isResolved();
 
               if (!resolved) {
-                substitution.resolve(substitutions, generalContext, specificContext);
+                substitution.resolve(substitutions, context);
               }
             });
 
@@ -297,7 +298,7 @@ export default class Substitutions {
     ];
   }
 
-  rollback(specificContext) {
+  rollback(context) {
     const array = [
       ...this.array
     ];
@@ -305,7 +306,7 @@ export default class Substitutions {
     leftDifference(array, this.savedArray);
 
     array.forEach((substitution) => {
-      this.removeSubstitution(substitution, specificContext);
+      this.removeSubstitution(substitution, context);
     });
 
     this.array = [
@@ -357,7 +358,7 @@ export default class Substitutions {
 
     return substitutions;
   }
-}
+});
 
 function leftDifference(arrayA, arrayB) {
   filter(arrayA, (elementA) => {

package/src/ontology/supposition.js

@@ -1,20 +1,26 @@
 "use strict";
 
 import ontology from "../ontology";
+import TemporaryContext from "../context/temporary";
 
 import { define } from "../ontology";
 import { assignAssignments } from "../utilities/assignments";
 import { subproofAssertionFromStatement } from "../utilities/context";
-import { statementFromJSON, procedureCallFromJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
+import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
 
 export default define(class Supposition {
-  constructor(node, string, statement, procedureCall) {
+  constructor(context, node, string, statement, procedureCall) {
+    this.context = context;
     this.node = node;
     this.string = string;
     this.statement = statement;
     this.procedureCall = procedureCall;
   }
 
+  getContext() {
+    return this.context;
+  }
+
   getNode() {
     return this.node;
   }
@@ -34,6 +40,10 @@ export default define(class Supposition {
   verify(context) {
     let verifies = false;
 
+    const temporaryContext = TemporaryContext.fromNothing(context);
+
+    context = temporaryContext; ///
+
     const suppositionString = this.string; ///
 
     context.trace(`Verifying the '${suppositionString}' supposition...`, this.node);
@@ -71,6 +81,8 @@ export default define(class Supposition {
     }
 
     if (verifies) {
+      this.context = context;
+
       context.debug(`...verified the '${suppositionString}' supposition.`, this.node);
     }
 
@@ -100,24 +112,38 @@ export default define(class Supposition {
   }
 
   unifyIndependently(substitutions, context) {
-    let unifiesIndependently;
+    let unifiesIndependently = false;
+
+    const suppositionString = this.string,  ///
+          generalContext = this.context,  ///
+          specificContext = context;  ///
+
+    context.trace(`Unifying the '${suppositionString}' supposition independently...`, this.node);
 
     if (this.statement !== null) {
-      const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, context);
+      const statementUnifiesIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
 
-      unifiesIndependently = statementResolvedIndependently;  ///
+      if (statementUnifiesIndependently) {
+        unifiesIndependently = true;
+      }
     }
 
     if (this.procedureCall !== null) {
       const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);
 
-      unifiesIndependently = procedureCallResolvedIndependently;  ///
+      if (procedureCallResolvedIndependently) {
+        unifiesIndependently = true;
+      }
+    }
+
+    if (unifiesIndependently) {
+      context.debug(`...unified the '${suppositionString}' supposition independenly.`, this.node);
     }
 
     return unifiesIndependently;
   }
 
-  unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext) {
+  unifyStepOrSubproof(stepOrSubproof, substitutions, context) {
     let stepOrSubproofUnifies = false;
 
     const stepOrSubProofStep = stepOrSubproof.isStep(),
@@ -131,40 +157,42 @@ export default define(class Supposition {
     substitutions.snapshot();
 
     if (subproof !== null) {
-      const subproofUnifies = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
+      const subproofUnifies = this.unifySubproof(subproof, substitutions, context);
 
       stepOrSubproofUnifies = subproofUnifies; ///
     }
 
     if (step !== null) {
-      const statementUnifies = this.unifyStep(step, substitutions, generalContext, specificContext);
+      const statementUnifies = this.unifyStep(step, substitutions, context);
 
       stepOrSubproofUnifies = statementUnifies;  ///
     }
 
     if (stepOrSubproofUnifies) {
-      substitutions.resolve(generalContext, specificContext);
+      substitutions.resolve(context);
     }
 
     stepOrSubproofUnifies ?
       substitutions.continue() :
-        substitutions.rollback(specificContext);
+        substitutions.rollback(context);
 
     return stepOrSubproofUnifies;
   }
 
-  unifyStep(step, substitutions, generalContext, specificContext) {
+  unifyStep(step, substitutions, context) {
     let stepUnifies;
 
+    context = step.getContext();
+
     const statement = step.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+          statementUnifies = this.unifyStatement(statement, substitutions, context);
 
     stepUnifies = statementUnifies;  ///
 
     return stepUnifies;
   }
 
-  unifySubproof(subproof, substitutions, generalContext, specificContext) {
+  unifySubproof(subproof, substitutions, context) {
     let subproofUnifies = false;
 
     const supposition = this, ///
@@ -172,52 +200,74 @@ export default define(class Supposition {
           suppositionStatement = supposition.getStatement(),
           suppositionStatementString = suppositionStatement.getString();
 
-    specificContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
+    context.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
 
     if (this.statement !== null) {
       const context = generalContext, ///
             subproofAssertion = subproofAssertionFromStatement(this.statement, context);
 
       if (subproofAssertion !== null) {
+        const generalContext = this.context,  ///
+              specificContext = context;  ///
+
         subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
       }
     }
 
     if (subproofUnifies) {
-      specificContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
+      context.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
     }
 
     return subproofUnifies;
   }
 
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
+  unifyStatement(statement, substitutions, context) {
     let statementUnifies;
 
     const supposition = this, ///
           statementString = statement.getString(),
           suppositionString = supposition.getString();
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
+    context.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
 
     if (this.statement !== null) {
+      const generalContext = this.context,  ///
+            specificContext = context;  ///
+
       statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
     }
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
+      context.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
     }
 
     return statementUnifies;
   }
 
   toJSON() {
-    const statementJSON = statementToStatementJSON(this.statement),
-          procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),
+    let frames,
+        terms;
+
+    frames = this.context.getFrames();
+
+    terms = this.context.getTerms();
+
+    const procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),
+          statementJSON = statementToStatementJSON(this.statement),
+          framesJSON = framesToFramesJSON(frames),
+          termsJSON = termsToTermsJSON(terms);
+
+    frames = framesJSON;  ///
+
+    terms = termsJSON;  ///
+
+    const procedureCall = procedureCallJSON,  ///
           statement = statementJSON,  ///
-          procedureCall = procedureCallJSON,  ///
           json = {
+            procedureCall,
             statement,
-            procedureCall
+            frames,
+            terms
           };
 
     return json;
@@ -226,8 +276,11 @@ export default define(class Supposition {
   static name = "Supposition";
 
   static fromJSON(json, context) {
-    const statement = statementFromJSON(json, context),
-          procedureCall = procedureCallFromJSON(json, context);
+    const terms = termsFromJSON(json, context),
+          frames = framesFromJSON(json, context),
+          statement = statementFromJSON(json, context),
+          procedureCall = procedureCallFromJSON(json, context),
+          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
 
     let string;
 
@@ -239,8 +292,11 @@ export default define(class Supposition {
       string = procedureCall.getString();
     }
 
-    const node = null,
-          supposition = new Supposition(node, string, statement, procedureCall);
+    const node = null;
+
+    context = temporaryContext; ///
+
+    const supposition = new Supposition(context, node, string, statement, procedureCall);
 
     return supposition;
   }
@@ -251,7 +307,11 @@ export default define(class Supposition {
           string = context.nodeAsString(node),
           statement = Statement.fromSuppositionNode(suppositionNode, context),
           procedureCall = ProcedureCall.fromSuppositionNode(suppositionNode, context),
-          supposition = new Supposition(node, string, statement, procedureCall);
+          temporaryContext = null;
+
+    context = temporaryContext; ///
+
+    const supposition = new Supposition(context, node, string, statement, procedureCall);
 
     return supposition
   }

package/src/ontology/term.js

@@ -35,40 +35,9 @@ export default define(class Term {
     this.type = type;
   }
 
-  getVariable(context) {
-    const { Variable } = ontology,
-          termNode = this.node, ///
-          variable = Variable.fromTermNode(termNode, context);
+  matchTermNode(termNode) { return this.node.match(termNode); }
 
-    return variable;
-  }
-
-  getVariables(context) {
-    const termNode = this.node,
-          variableNodes = termNode.getVariableNodes(),
-          variables = variableNodes.map((variableNode) => {
-            const { Variable } = ontology,
-                  variable = Variable.fromVariableNode(variableNode, context);
-
-            return variable;
-          });
-
-    compress(variables, (variableA, variableB) => {
-      const variableAEqualToVariableB = variableA.isEqualTo(variableB);
-
-      if (variableAEqualToVariableB) {
-        return true;
-      }
-    });
-
-    return variables;
-  }
-
-  matchTermNode(termNode) {
-    const termNodeMatches = this.node.match(termNode);
-
-    return termNodeMatches;
-  }
+  isSimple() { return this.node.isSimple();}
 
   isProvisional() { return this.type.isProvisional(); }
 
@@ -79,16 +48,9 @@ export default define(class Term {
     return equalTo;
   }
 
-  isSimple() {
-    const termNode = this.node,
-          singularVariableNode = termNode.getSingularVariableNode(),
-          simple = (singularVariableNode !== null);
-
-    return simple;
-  }
-
   isGrounded(definedVariables, context) {
-    const variables = this.getVariables(context);
+    const term  = this, ///
+          variables = variablesFromTerm(term, context);
 
     filter(variables, (variable) => {
       const definedVariablesIncludesVariable = definedVariables.includes(variable);
@@ -106,7 +68,8 @@ export default define(class Term {
   }
 
   isInitiallyGrounded(context) {
-    const variables = this.getVariables(context),
+    const term  = this, ///
+          variables = variablesFromTerm(term, context),
           variablesLength = variables.length,
           initiallyGrounded = (variablesLength === 0);
 
@@ -137,6 +100,10 @@ export default define(class Term {
     });
 
     if (verifies) {
+      const term = this;  ///
+
+      context.addTerm(term);
+
       context.debug(`...verified the '${termString}' term.`);
     }
 
@@ -274,3 +241,24 @@ export default define(class Term {
   }
 });
 
+export function variablesFromTerm(term, context) {
+  const termNode = term.getNode(),
+        variableNodes = termNode.getVariableNodes(),
+        variables = variableNodes.map((variableNode) => {
+          const variableIdentifier = variableNode.getVariableIdentifier(),
+                variable = context.findVariableByVariableIdentifier(variableIdentifier);
+
+          return variable;
+        });
+
+  compress(variables, (variableA, variableB) => {
+    const variableAEqualToVariableB = variableA.isEqualTo(variableB);
+
+    if (variableAEqualToVariableB) {
+      return true;
+    }
+  });
+
+  return variables;
+}
+

package/src/ontology/topLevelAssertion.js

@@ -4,7 +4,6 @@ import { arrayUtilities } from "necessary";
 
 import ontology from "../ontology";
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
 
 import { labelsFromJSON,
          deductionFromJSON,
@@ -112,7 +111,7 @@ export default class TopLevelAssertion {
     const labelsVerify = this.verifyLabels();
 
     if (labelsVerify) {
-      const localContext = LocalContext.fromContext(this.context),
+      const localContext = LocalContext.fromNothing(this.context),
             context = localContext, ///
             suppositionsVerify = this.verifySuppositions(context);
 
@@ -175,7 +174,8 @@ export default class TopLevelAssertion {
     if (this.proof === null) {
       proofVerifies = true;
     } else {
-      const substitutions = Substitutions.fromNothing();
+      const { Substitutions } = ontology,
+            substitutions = Substitutions.fromNothing();
 
       proofVerifies = this.proof.verify(substitutions, this.deduction, context);
     }
@@ -212,10 +212,10 @@ export default class TopLevelAssertion {
     return hypothesesCorrelate;
   }
 
-  unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext) {
+  unifyStatementWithDeduction(statement, substitutions, context) {
     let statementUnifiesWithDeduction = false;
 
-    const statementUnifies = this.deduction.unifyStatement(statement, substitutions, generalContext, specificContext);  ///
+    const statementUnifies = this.deduction.unifyStatement(statement, substitutions, context);  ///
 
     if (statementUnifies) {
       statementUnifiesWithDeduction = true;
@@ -225,39 +225,37 @@ export default class TopLevelAssertion {
   }
 
   unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context) {
-    let statementAndStepsOrSubproofsUnify = false;
+    let statementAndStepsOrSubproofsUnifies = false;
 
     const hypothesesCorrelate = this.correlateHypotheses(context);
 
     if (hypothesesCorrelate) {
-      const generalContext = this.context, ///
-            specificContext = context, ///
-            statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
+      const statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
 
       if (statementUnifiesWithDeduction) {
-        const stepsOrSubproofsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext);
+        const stepsOrSubproofsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, context);
 
         if (stepsOrSubproofsUnifyWithSuppositions) {
           const substitutionsResolved = substitutions.areResolved();
 
           if (substitutionsResolved) {
-            statementAndStepsOrSubproofsUnify = true;
+            statementAndStepsOrSubproofsUnifies = true;
           }
         }
       }
     }
 
-    return statementAndStepsOrSubproofsUnify;
+    return statementAndStepsOrSubproofsUnifies;
   }
 
   unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext) {
-    let stepsOrSubproofsUnifyWithSupposition = false;
+    let stepsOrSubproofsUnifiesWithSupposition = false;
 
     const context = specificContext,  ///
           suppositionUnifiesIndependently = supposition.unifyIndependently(substitutions, context);
 
     if (suppositionUnifiesIndependently) {
-      stepsOrSubproofsUnifyWithSupposition = true;
+      stepsOrSubproofsUnifiesWithSupposition = true;
     } else {
       const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {
         const stepOrSubproofUnifies = supposition.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
@@ -268,20 +266,20 @@ export default class TopLevelAssertion {
       }) || null;
 
       if (stepOrSubproof !== null) {
-        stepsOrSubproofsUnifyWithSupposition = true;
+        stepsOrSubproofsUnifiesWithSupposition = true;
       }
     }
 
-    return stepsOrSubproofsUnifyWithSupposition;
+    return stepsOrSubproofsUnifiesWithSupposition;
   }
 
   unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext) {
     stepsOrSubproofs = reverse(stepsOrSubproofs); ///
 
     const stepsOrSubproofsUnifyWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
-      const stepsOrSubproofsUnifyWithSupposition = this.unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext);
+      const stepsOrSubproofsUnifiesWithSupposition = this.unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext);
 
-      if (stepsOrSubproofsUnifyWithSupposition) {
+      if (stepsOrSubproofsUnifiesWithSupposition) {
         return true;
       }
     });

package/src/ontology/topLevelMetaAssertion.js

@@ -2,7 +2,6 @@
 
 import ontology from "../ontology";
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
 
 import { proofFromProofNode, deductionFromDeductionNode, suppositionsFromSuppositionNodes } from "./topLevelAssertion";
 import { labelFromJSON,
@@ -73,7 +72,7 @@ export default class TopLevelMetaAssertion {
     const labelVerifies = this.verifyLabel();
 
     if (labelVerifies) {
-      const localContext = LocalContext.fromContext(this.context),
+      const localContext = LocalContext.fromNothing(this.context),
             context = localContext, ///
             suppositionsVerify = this.verifySuppositions(context);
 
@@ -169,7 +168,8 @@ export default class TopLevelMetaAssertion {
   }
 
   static fromNode(Class, node, context) {
-    const topLevelAssertionNode = node, ///
+    const { Substitutions } = ontology,
+          topLevelAssertionNode = node, ///
           proofNode = topLevelAssertionNode.getProofNode(),
           labelNode = topLevelAssertionNode.getLabelNode(),
           deductionNode = topLevelAssertionNode.getDeductionNode(),