occam-verify-cli 1.0.387 → 1.0.396

package/src/ontology/substitution/term.js

@@ -1,16 +1,18 @@
 "use strict";
 
-import ontology from "../../ontology";
 import Substitution from "../substitution";
 import TermSubstitutionPartialContext from "../../context/partial/substitution/term";
 
-import { define } from "../../ontology";
+import ontology, { define } from "../../ontology";
+import { nodeQuery } from "../../utilities/query";
 import { stripBracketsFromTerm } from "../../utilities/brackets";
-import { stripBracketsFromTermNode } from "../../utilities/brackets";
+import { variableIdentifierFromVariableNode } from "../../utilities/variable";
+
+const termVariableNodeQuery = nodeQuery("/term/variable!");
 
 export default define(class TermSubstitution extends Substitution {
-  constructor(string, node, tokens, term, variable) {
-    super(string, node, tokens);
+  constructor(context, string, node, tokens, term, variable) {
+    super(context, string, node, tokens);
 
     this.term = term;
     this.variable = variable;
@@ -24,6 +26,13 @@ export default define(class TermSubstitution extends Substitution {
     return this.variable;
   }
 
+  getReplacementNode() {
+    const termNode = this.term.getNode(),
+          replacementNode = termNode; ///
+
+    return replacementNode;
+  }
+
   isTrivial() {
     const termString = this.term.getString(),
           variableString = this.variable.getString(),
@@ -32,68 +41,125 @@ export default define(class TermSubstitution extends Substitution {
     return trivial;
   }
 
-  isTermEqualTo(term, context) {
+  isTermEqualToTerm(term, context) {
     term = stripBracketsFromTerm(term, context); ///
 
-    const termEqualTo = this.term.isEqualTo(term);
+    const termEqualToTerm = this.term.isEqualTo(term);
 
-    return termEqualTo;
+    return termEqualToTerm;
   }
 
-  isVariableEqualTo(variable) { return this.variable.isEqualTo(variable); }
+  isTermVariableEqualToTerm(termVariable, context) {
+    let termVariableEqualToTerm = false;
+
+    const termNode = this.term.getNode();
+
+    let termVariableNode;
+
+    termVariableNode = termVariableNodeQuery(termNode);
+
+    if (termVariableNode !== null) {
+      const termVariableNodeA = termVariableNode; ///
+
+      termVariableNode = termVariable.getNode();
+
+      const termVariableNodeB = termVariableNode, ///
+            termVariableNodeAMatchesTermVariableNodeB = termVariableNodeA.match(termVariableNodeB);
+
+      if (termVariableNodeAMatchesTermVariableNodeB) {
+        termVariableEqualToTerm = true;
+      }
+    }
+
+    return termVariableEqualToTerm;
+  }
 
   matchParameter(parameter) { return this.variable.matchParameter(parameter); }
 
-  getReplacementNode() {
-    const termNode = this.term.getNode(),
-          replacementNode = termNode; ///
+  verify(context) {
+    let verifies = false;
 
-    return replacementNode;
+    const termSubstitutionString = this.string;  ///
+
+    context.trace(`Verifiying the '${termSubstitutionString}' term substitutin...`);
+
+    const termSimple = this.term.isSimple();
+
+    if (termSimple) {
+      if (this.variable === null) {
+        context.debug(`The specific term is not simple.`);
+      } else {
+        const variableIdentigier = this.variable.getIdentifier(),
+              variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentigier);
+
+        if (variablePresent) {
+          const variable = this.term.getVariable(),
+                variableIdentigier = variable.getIdentifier(),
+                variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentigier);
+
+          if (variablePresent) {
+            verifies = true;
+          } else {
+            const variableString = variable.getString();
+
+            context.debug(`The '${variableString}' variable is not present.`);
+          }
+        } else {
+          const variableString = this.variable.getString();
+
+          context.debug(`The '${variableString}' variable is not present.`);
+        }
+      }
+    } else {
+      context.debug(`The general term is not simple.`);
+    }
+
+    if (verifies) {
+      const substititoin = this;  ///
+
+      context.addSubstitution(substititoin);
+
+      context.debug(`...verified the '${termSubstitutionString}' term substitutin.`);
+    }
+
+    return verifies;
   }
 
-  static fromStatementNode(statementNode, context) {
+  static name = "TermSubstitution";
+
+  static fromStatement(statement, context) {
     let termSubstitution = null;
 
-    const termSubstitutionNode = statementNode.getTermSubstitutionNode();
+    const statementNode = statement.getNode(),
+          termSubstitutionNode = statementNode.getTermSubstitutionNode();
 
     if (termSubstitutionNode !== null) {
-      const lastTermNode = termSubstitutionNode.getLastTermNode(),
+      const { Term, Variable } = ontology,
             firstTermNode = termSubstitutionNode.getFirstTermNode(),
-            singularVariableNode = lastTermNode.getSingularVariableNode(lastTermNode);
-
-      if (singularVariableNode !== null) {
-        const { Term, Variable } = ontology,
-              termNode = firstTermNode, ///
-              variableNode = singularVariableNode,  ///
-              term = Term.fromTermNode(termNode, context),
-              variable = Variable.fromVariableNode(variableNode, context),
-              node = termSubstitutionNode,  ///
-              tokens = context.nodeAsTokens(node),
-              string = stringFromTermAndVariable(term, variable);
-
-        termSubstitution = new TermSubstitution(string, node, tokens, term, variable);
-      }
+            lastVariableNode = termSubstitutionNode.getLastVariableNode(),
+            termNode = firstTermNode, ///
+            variableNode = lastVariableNode,  ///
+            term = Term.fromTermNode(termNode, context),
+            variable = Variable.fromVariableNode(variableNode, context),
+            node = termSubstitutionNode,  ///
+            tokens = context.nodeAsTokens(node),
+            string = stringFromTermAndVariable(term, variable);
+
+      termSubstitution = new TermSubstitution(context, string, node, tokens, term, variable);
     }
 
     return termSubstitution;
   }
 
   static fromTernAndVariable(term, variable, context) {
-    let termNode = term.getNode();
-
-    termNode = stripBracketsFromTermNode(termNode); ///
-
-    const { Term } = ontology;
-
-    term = Term.fromTermNode(termNode, context);
-
-    const string = stringFromTermAndVariable(term, variable),
-          lexer = context.getLexer(),
+    const lexer = context.getLexer(),
           parser = context.getParser(),
+          string = stringFromTermAndVariable(term, variable),
           termSubstitutionPartialContext = TermSubstitutionPartialContext.fromStringLexerAndParser(string, lexer, parser),
           node = termSubstitutionPartialContext.getNode(),
-          tokens = termSubstitutionPartialContext.getTokens(),
-          termSubstitution = new TermSubstitution(string, node, tokens, term, variable);
+          tokens = termSubstitutionPartialContext.getTokens();
+
+    const termSubstitution = new TermSubstitution(context, string, node, tokens, term, variable);
 
     return termSubstitution;
   }

package/src/ontology/substitution.js

@@ -1,12 +1,17 @@
 "use strict";
 
 export default class Substitution {
-  constructor(string, node, tokens) {
+  constructor(context, string, node, tokens) {
+    this.context = context;
     this.string = string;
     this.node = node;
     this.tokens = tokens;
   }
 
+  getContext() {
+    return this.context;
+  }
+
   getString() {
     return this.string;
   }
@@ -87,46 +92,46 @@ export default class Substitution {
     return equalTo;
   }
 
-  isTermEqualTo(term) {
-    const termEqualTo = false;
+  isTermEqualToTerm(term, context) {
+    const termEqualToTerm = false;
 
-    return termEqualTo;
+    return termEqualToTerm;
   }
 
-  isFrameEqualTo(frame) {
-    const frameEqualTo = false;
+  isFrameEqualToFrame(frame) {
+    const frameEqualToFrame = false;
 
-    return frameEqualTo;
+    return frameEqualToFrame;
   }
 
-  isVariableEqualTo(variable) {
-    const variableEqualTo = false;
+  isTermVariableEqualToTerm(termVariable, context) {
+    const termVariableEqualToTerm = false;
 
-    return variableEqualTo;
+    return termVariableEqualToTerm;
   }
 
-  isReferenceEqualTo(reference) {
-    const referenceEqualTo = false;
+  isReferenceEqualToReference(reference, context) {
+    const referenceEqualToReference = false;
 
-    return referenceEqualTo;
+    return referenceEqualToReference;
   }
 
-  isStatementEqualTo(statement) {
-    const statementEqualTo = false;
+  isStatementEqualToStatement(statement, context) {
+    const statementEqualToStatement = false;
 
-    return statementEqualTo;
+    return statementEqualToStatement;
   }
 
-  isMetavariableEqualTo(metavariable) {
-    const metavariableEqualTo = false;
+  isMetavariableEqualToMetavariable(metavariable) {
+    const metavariableEqualToMetavariable = false;
 
-    return metavariableEqualTo;
+    return metavariableEqualToMetavariable;
   }
 
-  isSubstitutionEqualTo(substitution) {
-    const substitutionEqualTo = (substitution === null);
+  isSubstitutionEqualToSubstitution(substitution) {
+    const substitutionEqualToSubstitution = (substitution === null);
 
-    return substitutionEqualTo;
+    return substitutionEqualToSubstitution;
   }
 
   resolve(substitutions, context) {

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);
     }
 
@@ -117,7 +129,7 @@ export default define(class Supposition {
     return unifiesIndependently;
   }
 
-  unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext) {
+  unifyStepOrSubproof(stepOrSubproof, substitutions, context) {
     let stepOrSubproofUnifies = false;
 
     const stepOrSubProofStep = stepOrSubproof.isStep(),
@@ -131,40 +143,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 +186,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 +262,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 +278,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 +293,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

@@ -64,11 +64,7 @@ export default define(class Term {
     return variables;
   }
 
-  matchTermNode(termNode) {
-    const termNodeMatches = this.node.match(termNode);
-
-    return termNodeMatches;
-  }
+  matchTermNode(termNode) { return this.node.match(termNode); }
 
   isProvisional() { return this.type.isProvisional(); }
 
@@ -137,6 +133,10 @@ export default define(class Term {
     });
 
     if (verifies) {
+      const term = this;  ///
+
+      context.addTerm(term);
+
       context.debug(`...verified the '${termString}' term.`);
     }
 

package/src/ontology/topLevelAssertion.js

@@ -112,7 +112,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);
 
@@ -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

@@ -73,7 +73,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);