occam-verify-cli 0.0.941 → 0.0.942

package/src/rule.js

@@ -3,6 +3,7 @@
 import Label from "./label";
 import Premise from "./premise";
 import Conclusion from "./conclusion";
+import Substitutions from "./substitutions";
 
 import { reverse, correlate } from "./utilities/array";
 
@@ -34,7 +35,7 @@ export default class Rule {
     let statementUnified = false;
 
     const proofSteps = localContext.getProofSteps(),
-          substitutions = [],
+          substitutions = Substitutions.fromNothing(),
           premisesUnified = unifyPremises(this.premises, proofSteps, substitutions, this.fileContext, localContext);
 
     if (premisesUnified) {
@@ -133,6 +134,8 @@ function matchPremise(premise, proofStep, substitutions, fileContext, localConte
   const subproofNode = proofStep.getSubproofNode(),
         statementNode = proofStep.getStatementNode();
 
+  substitutions.snapshot();
+
   if (subproofNode !== null) {
     const subproofUnified = premise.unifySubproof(subproofNode, substitutions, fileContext, localContext);
 
@@ -145,6 +148,10 @@ function matchPremise(premise, proofStep, substitutions, fileContext, localConte
     premiseUnified = statementUnified;  ///
   }
 
+  premiseUnified ?
+    substitutions.continue() :
+      substitutions.rollback();
+
   return premiseUnified;
 }
 
@@ -165,8 +172,17 @@ function unifyPremises(premises, proofSteps, substitutions, fileContext, localCo
 }
 
 function unifyConclusion(conclusion, statementNode, substitutions, fileContext, localContext) {
-  const statementUnified = conclusion.unifyStatement(statementNode, substitutions, fileContext, localContext),
-        conclusionUnified = statementUnified; ///
+  let conclusionUnified;
+
+  substitutions.snapshot();
+
+  const statementUnified = conclusion.unifyStatement(statementNode, substitutions, fileContext, localContext);
+
+  conclusionUnified = statementUnified; ///
+
+  conclusionUnified ?
+    substitutions.continue() :
+      substitutions.rollback();
 
   return conclusionUnified;
 }

package/src/substitution/termForVariable.js

@@ -106,7 +106,7 @@ function substituteTermNode(termNode, substitutions) {
   const termVariableNode = variableNodeQuery(termNode);
 
   if (termVariableNode !== null) {
-    substitutions.some((substitution) => {
+    substitutions.someSubstitution((substitution) => {
       const substitutionMatchesVariableNode = substitution.matchVariableNode(termVariableNode);
 
       if (substitutionMatchesVariableNode) {
@@ -121,7 +121,7 @@ function substituteTermNode(termNode, substitutions) {
 }
 
 function substituteVariableNode(variableNode, substitutions) {
-  substitutions.some((substitution) => {
+  substitutions.someSubstitution((substitution) => {
     const substitutionMatchesVariableNode = substitution.matchVariableNode(variableNode);
 
     if (substitutionMatchesVariableNode) {

package/src/substitutions.js

@@ -0,0 +1,103 @@
+"use strict";
+
+import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
+
+import { prune, compare } from "./utilities/array";
+
+export default class Substitutions {
+  constructor(array, savedArray) {
+    this.array = array;
+    this.savedArray = savedArray;
+  }
+
+  getArray() {
+    return this.array;
+  }
+
+  getSavedArray() {
+    return this.savedArray;
+  }
+
+  hasChanged() {
+    const compares = compare(this.array, this.savedArray),
+          changed = !compares;  ///
+
+    return changed;
+  }
+
+  findSubstitution(callback) { return this.array.find(callback); }
+
+  someSubstitution(callback) { return this.array.some(callback); }
+
+  everySubstitution(callback) { return this.array.every(callback); }
+
+  addSubstitution(substitution) { this.array.push(substitution); }
+
+  removeSubstitution(substitution) {
+    const substitutionA = substitution; ///
+
+    prune(this.array, (substitution) => {
+      const substitutionB = substitution; ///
+
+      if (substitutionA !== substitutionB) {
+        return true;
+      }
+    });
+  }
+
+  snapshot() {
+    this.savedArray = [
+      ...this.array
+    ];
+  }
+
+  rollback() {
+    const start = 0,
+          end = Infinity;
+
+    this.array.splice(start, end, ...this.savedArray);
+
+    this.savedArray = null;
+  }
+
+  continue() {
+    this.savedArray = null;
+  }
+
+  transform() {
+    ///
+  }
+
+  toJSON(tokens) {
+    const json = this.array.map((substitution) => {
+      const substitutionJSON = substitution.toJSON(tokens);
+
+      return substitutionJSON;
+    });
+
+    return json;
+  }
+
+  static fromNothing() {
+    const array = [],
+          savedArray = null,
+          substitutions = new Substitutions(array, savedArray);
+
+    return substitutions;
+  }
+
+  static fromJSONAndFileContext(json, fileContext) {
+    const substitutionsJSON = json, ///
+          array = substitutionsJSON.map((substitutionJSON) => {
+            const json = substitutionJSON,  ///
+                  statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromJSONAndFileContext(json, fileContext),
+                  substitution = statementForMetavariableSubstitution;  ///
+
+            return substitution;
+          }),
+          savedArray = null,
+          substitutions = new Substitutions(array, savedArray);
+
+    return substitutions;
+  }
+}

package/src/topLevelAssertion.js

@@ -3,7 +3,7 @@
 import Label from "./label";
 import Consequent from "./consequent";
 import Supposition from "./supposition";
-import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
+import Substitutions from "./substitutions";
 
 import { reverse, correlate } from "./utilities/array";
 
@@ -40,7 +40,7 @@ export default class TopLevelAssertion {
     let statementUnified = false;
 
     const proofSteps = localContext.getProofSteps(),
-          substitutions = [],
+          substitutions = Substitutions.fromNothing(),
           suppositionsUnified = unifySuppositions(this.suppositions, proofSteps, substitutions, this.fileContext, localContext);
 
     if (suppositionsUnified) {
@@ -76,11 +76,7 @@ export default class TopLevelAssertion {
             return suppositionJSON;
           }),
           consequentJSON = this.consequent.toJSON(tokens),
-          substitutionsJSON = this.substitutions.map((substitution) => {
-            const substitutionJSON = substitution.toJSON();
-
-            return substitutionJSON;
-          }),
+          substitutionsJSON = this.substitutions.toJSON(tokens),
           labels = labelsJSON,  ///
           suppositions = suppositionsJSON,  ///
           consequent = consequentJSON,  ///
@@ -126,13 +122,9 @@ export default class TopLevelAssertion {
 
     const substitutionsJSON = substitutions;  ///
 
-    substitutions = substitutionsJSON.map((substitutionJSON) => {
-      const json = substitutionJSON,  ///
-            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromJSONAndFileContext(json, fileContext),
-            substitution = statementForMetavariableSubstitution;  ///
+    json = substitutionsJSON; ///
 
-      return substitution;
-    });
+    substitutions = Substitutions.fromJSONAndFileContext(json, fileContext);
 
     return new Class(labels, suppositions, consequent, substitutions, fileContext);  ///
   }
@@ -159,6 +151,8 @@ function unifySuppositions(suppositions, proofSteps, substitutions, fileContext,
 function unifySupposition(supposition, proofStep, substitutions, fileContext, localContext) {
   let suppositionUnified = false;
 
+  substitutions.snapshot();
+
   const subproofNode = proofStep.getSubproofNode(),
         statementNode = proofStep.getStatementNode();
 
@@ -174,12 +168,25 @@ function unifySupposition(supposition, proofStep, substitutions, fileContext, lo
     suppositionUnified = statementUnified;  ///
   }
 
+  suppositionUnified ?
+    substitutions.continue() :
+      substitutions.rollback();
+
   return suppositionUnified;
 }
 
 function unifyConsequent(consequent, statementNode, substitutions, fileContext, localContext) {
-  const statementUnified = consequent.unifyStatement(statementNode, substitutions, fileContext, localContext),
-        consequentUnified = statementUnified; ///
+  let consequentUnified;
+
+  substitutions.snapshot();
+
+  const statementUnified = consequent.unifyStatement(statementNode, substitutions, fileContext, localContext);
+
+  consequentUnified = statementUnified; ///
+
+  consequentUnified ?
+    substitutions.continue() :
+      substitutions.rollback();
 
   return consequentUnified;
 }

package/src/unify/metavariableAgainstStatement.js

@@ -7,7 +7,7 @@ import StatementForMetavariableSubstitution from "../substitution/statementForMe
 export default function unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, unifyAhead) {
   let metavariableUnifiedAgainstStatement = false;
 
-  const substitution = substitutions.find((substitution) => {
+  const substitution = substitutions.findSubstitution((substitution) => {
     const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
 
     if (substitutionMatchesMetavariableNodeA) {
@@ -67,12 +67,12 @@ export default function unifyMetavariableAgainstStatement(metavariableNodeA, sta
           statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeStatementNodeAndSubstitutionNode(metavariableNode, statementNode, substitutionNode),
           substitution = statementForMetavariableSubstitution;  ///
 
-    substitutions.push(substitution);
+    substitutions.addSubstitution(substitution);
 
     unifiedAhead = unifyAhead();
 
     if (!unifiedAhead) {
-      substitutions.pop();
+      substitutions.removeSubstitution(substitution);
     }
 
     metavariableUnifiedAgainstStatement = unifiedAhead;  ///

package/src/unify/variableAgainstTerm.js

@@ -11,7 +11,7 @@ const variableNodeQuery = nodeQuery("/term/variable");
 export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
   let variableUnifiedAgainstTerm = false;
 
-  const substitution = substitutions.find((substitution) => {
+  const substitution = substitutions.findSubstitution((substitution) => {
     const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
 
     if (substitutionMatchesVariableNodeA) {
@@ -54,12 +54,12 @@ export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, subst
                         termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
                         substitution = termForVariableSubstitution;  ///
 
-                  substitutions.push(substitution);
+                  substitutions.addSubstitution(substitution);
 
                   verifiedAhead = verifyAhead();
 
                   if (!verifiedAhead) {
-                    substitutions.pop();
+                    substitutions.removeSubstitution(substitution);
                   }
                 }
               }

package/src/utilities/array.js

@@ -12,6 +12,21 @@ export function reverse(array) {
   return array;
 }
 
+export function compare(arrayA, arrayB) {
+  let compares = false;
+
+  const arrayALength = arrayA.length,
+        arrayBLength = arrayB.length;
+
+  if (arrayALength === arrayBLength) {
+    const correlates = correlate(arrayA, arrayB);
+
+    compares = correlates;  ///
+  }
+
+  return compares;
+}
+
 export function correlate(arrayA, arrayB, callback) {
   arrayB = [  ///
     ...arrayB

package/src/verify/axiom.js

@@ -3,6 +3,7 @@
 import Axiom from "../axiom";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -37,8 +38,8 @@ export default function verifyAxiom(axiomNode, fileContext) {
 
       if (consequentVerified) {
         const firstConsequent = first(consequents),
+              substitutions = Substitutions.fromNothing(),
               consequent = firstConsequent, ///
-              substitutions = [],
               axiom = Axiom.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
         fileContext.addAxiom(axiom);

package/src/verify/conjecture.js

@@ -4,6 +4,7 @@ import Conjecture from "../conjecture";
 import verifyProof from "../verify/proof";
 import verifyLabels from "../verify/labels";
 import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -43,10 +44,12 @@ export default function verifyConjecture(conjectureNode, fileContext) {
               consequent = firstConsequent; ///
 
         if (proofNode !== null) {
-          verifyProof(proofNode, consequent, localContext);
+          const substitutions = Substitutions.fromNothing();
+
+          verifyProof(proofNode, consequent, substitutions, localContext);
         }
 
-        const substitutions = [],
+        const substitutions = Substitutions.fromNothing(),
               conjecture = Conjecture.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
         fileContext.addConjecture(conjecture);

package/src/verify/lemma.js

@@ -4,6 +4,7 @@ import Lemma from "../lemma";
 import verifyProof from "../verify/proof";
 import verifyLabels from "../verify/labels";
 import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -45,11 +46,11 @@ export default function verifyLemma(lemmaNode, fileContext) {
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
               statementNode = consequent.getStatementNode(),
-              substitutions = [],
+              substitutions = Substitutions.fromNothing(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {
-          const substitutions = [],
+          const substitutions = Substitutions.fromNothing(),
                 lemma = Lemma.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addLemma(lemma);

package/src/verify/metaLemma.js

@@ -4,6 +4,7 @@ import MetaLemma from "../metaLemma";
 import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -45,7 +46,7 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
               statementNode = consequent.getStatementNode(),
-              substitutions = [],
+              substitutions = Substitutions.fromNothing(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {

package/src/verify/metatheorem.js

@@ -4,6 +4,7 @@ import verifyProof from "../verify/proof";
 import Metatheorem from "../metatheorem";
 import verifyLabels from "../verify/labels";
 import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -41,7 +42,7 @@ export default function verifyMetatheorem(metatheoremNode, fileContext) {
         const proofNode = proofNodeQuery(metatheoremNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
-              substitutions = [],
+              substitutions = Substitutions.fromNothing(),
               statementNode = consequent.getStatementNode(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 

package/src/verify/rule.js

@@ -9,6 +9,7 @@ import verifyConclusion from "../verify/conclusion";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
+import Substitutions from "../substitutions";
 
 const proofNodeQuery = nodeQuery("/rule/proof!"),
       labelNodesQuery = nodesQuery("/rule/label"),
@@ -45,7 +46,7 @@ export default function verifyRule(ruleNode, fileContext) {
               conclusion = firstConclusion; ///
 
         if (proofNode !== null) {
-          const substitutions = [],
+          const substitutions = Substitutions.fromNothing(),
                 statementNode = conclusion.getStatementNode();
 
           proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);

package/src/verify/theorem.js

@@ -4,6 +4,7 @@ import Theorem from "../theorem";
 import verifyProof from "../verify/proof";
 import verifyLabels from "../verify/labels";
 import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -42,11 +43,11 @@ export default function verifyTheorem(theoremNode, fileContext) {
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
               statementNode = consequent.getStatementNode(),
-              substitutions = [],
+              substitutions = Substitutions.fromNothing(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {
-          const substitutions = [],
+          const substitutions = Substitutions.fromNothing(),
                 theorem = Theorem.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addTheorem(theorem);