occam-verify-cli 0.0.683 → 0.0.684

package/src/assignment/equality.js

@@ -0,0 +1,21 @@
+"use strict";
+
+export default class EqualityAssignment {
+  constructor(equality) {
+    this.equality = equality;
+  }
+
+  getEquality() {
+    return this.equality;
+  }
+
+  assign(localContext) {
+    localContext.addEquality(this.equality);
+  }
+
+  static fromEquality(equality) {
+    const assignmentAssignment = new EqualityAssignment(equality);
+
+    return assignmentAssignment;
+  }
+}

package/src/assignment/variable.js

@@ -0,0 +1,21 @@
+"use strict";
+
+export default class VariableAssignment {
+  constructor(variable) {
+    this.variable = variable;
+  }
+
+  getVariable() {
+    return this.variable;
+  }
+
+  assign(localContext) {
+    localContext.addVariable(this.variable);
+  }
+
+  static fromVariable(variable) {
+    const assignmentAssignment = new VariableAssignment(variable);
+
+    return assignmentAssignment;
+  }
+}

package/src/axiom.js

@@ -5,5 +5,5 @@ import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
 export default class Axiom extends AxiomLemmaTheoremConjecture {
   static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Axiom, json, fileContext); }
 
-  static fromLabelsSuppositionsConsequentAndProofContext(labels, suppositions, consequent, proofContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequentAndProofContext(Axiom, labels, suppositions, consequent, proofContext); }
+  static fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequentAndLocalContext(Axiom, labels, suppositions, consequent, localContext); }
 }

package/src/axiomLemmaTheoremConjecture.js

@@ -3,17 +3,17 @@
 import Label from "./label";
 import Consequent from "./consequent";
 import Supposition from "./supposition";
-import ProofContext from "./context/proof";
+import LocalContext from "./context/local";
 
 import { prune } from "./utilities/array";
 import { someSubArray } from "./utilities/array";
 
 export default class AxiomLemmaTheoremConjecture {
-  constructor(labels, suppositions, consequent, proofContext) {
+  constructor(labels, suppositions, consequent, localContext) {
     this.labels = labels;
     this.suppositions = suppositions;
     this.consequent = consequent;
-    this.proofContext = proofContext;
+    this.localContext = localContext;
   }
 
   getLabels() {
@@ -28,8 +28,8 @@ export default class AxiomLemmaTheoremConjecture {
     return this.consequent;
   }
 
-  getProofContext() {
-    return this.proofContext;
+  getLocalContext() {
+    return this.localContext;
   }
 
   matchLabelName(labelName) {
@@ -45,27 +45,27 @@ export default class AxiomLemmaTheoremConjecture {
     return labelNameMatches;
   }
 
-  matchStatement(statementNode, statementProofContext) {
+  matchStatement(statementNode, statementLocalContext) {
     let statementNatches;
 
     const suppositionsLength = this.suppositions.length;
 
     if (suppositionsLength === 0) {
       const substitutions = [],
-            consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.proofContext, statementProofContext);
+            consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.localContext, statementLocalContext);
 
       statementNatches = consequentMatches; ///
     } else {
-      const proofSteps = statementProofContext.getProofSteps();
+      const proofSteps = statementLocalContext.getProofSteps();
 
       statementNatches = someSubArray(proofSteps, suppositionsLength, (proofSteps) => {
         let suppositionsMatchConsequent = false;
 
         const substitutions = [],
-              suppositionsMatch = matchSuppositions(this.suppositions, proofSteps, substitutions, this.proofContext, statementProofContext);
+              suppositionsMatch = matchSuppositions(this.suppositions, proofSteps, substitutions, this.localContext, statementLocalContext);
 
         if (suppositionsMatch) {
-          const consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.proofContext, statementProofContext);
+          const consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.localContext, statementLocalContext);
 
           suppositionsMatchConsequent = consequentMatches;  ///
         }
@@ -91,16 +91,16 @@ export default class AxiomLemmaTheoremConjecture {
             return suppositionJSON;
           }),
           consequentJSON = this.consequent.toJSON(tokens),
-          proofContextJSON = this.proofContext.toJSON(tokens),
+          localContextJSON = this.localContext.toJSON(tokens),
           labels = labelsJSON,  ///
           suppositions = suppositionsJSON,  ///
           consequent = consequentJSON,  ///
-          proofContext = proofContextJSON,  ///
+          localContext = localContextJSON,  ///
           json = {
             labels,
             suppositions,
             consequent,
-            proofContext
+            localContext
           };
 
     return json;
@@ -118,7 +118,7 @@ export default class AxiomLemmaTheoremConjecture {
       return label;
     });
 
-    let { suppositions, consequent, proofContext } = json;
+    let { suppositions, consequent, localContext } = json;
 
     const suppositionsJSON = suppositions;  ///
 
@@ -135,25 +135,25 @@ export default class AxiomLemmaTheoremConjecture {
 
     consequent = Consequent.fromJSONAndFileContext(json, fileContext);
 
-    const proofContextJSON = proofContext;  ///
+    const localContextJSON = localContext;  ///
 
-    json = proofContextJSON;  ///
+    json = localContextJSON;  ///
 
-    proofContext = ProofContext.fromJSONAndFileContext(json, fileContext);
+    localContext = LocalContext.fromJSONAndFileContext(json, fileContext);
 
-    return new Class(labels, suppositions, consequent, proofContext);  ///
+    return new Class(labels, suppositions, consequent, localContext);  ///
   }
 
-  static fromLabelsSuppositionsConsequentAndProofContext(Class, labels, suppositions, consequent, proofContext) { return new Class(labels, suppositions, consequent, proofContext); }
+  static fromLabelsSuppositionsConsequentAndLocalContext(Class, labels, suppositions, consequent, localContext) { return new Class(labels, suppositions, consequent, localContext); }
 }
 
-function matchSupposition(supposition, proofSteps, substitutions, proofContext, statementProofContext) {
+function matchSupposition(supposition, proofSteps, substitutions, localContext, statementLocalContext) {
   const proofStep = prune(proofSteps, (proofStep) => {
     const subproofNode = proofStep.getSubproofNode(),
           statementNode = proofStep.getStatementNode();
 
     if (subproofNode !== null) {
-      const subProofMatches = supposition.matchSubproofNode(subproofNode, substitutions, proofContext, statementProofContext);
+      const subProofMatches = supposition.matchSubproofNode(subproofNode, substitutions, localContext, statementLocalContext);
 
       if (!subProofMatches) {  ///
         return true;
@@ -161,7 +161,7 @@ function matchSupposition(supposition, proofSteps, substitutions, proofContext,
     }
 
     if (statementNode !== null) {
-      const statementMatches = supposition.matchStatementNode(statementNode, substitutions, proofContext, statementProofContext);
+      const statementMatches = supposition.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext);
 
       if (!statementMatches) {  ///
         return true;
@@ -175,9 +175,9 @@ function matchSupposition(supposition, proofSteps, substitutions, proofContext,
   return suppositionMatches;
 }
 
-function matchSuppositions(suppositions, proofSteps, substitutions, proofContext, statementProofContext) {
+function matchSuppositions(suppositions, proofSteps, substitutions, localContext, statementLocalContext) {
   const suppositionsMatch = suppositions.every((supposition) => {
-    const suppositionMatches = matchSupposition(supposition, proofSteps, substitutions, proofContext, statementProofContext);
+    const suppositionMatches = matchSupposition(supposition, proofSteps, substitutions, localContext, statementLocalContext);
 
     if (suppositionMatches) {
       return true;
@@ -187,8 +187,8 @@ function matchSuppositions(suppositions, proofSteps, substitutions, proofContext
   return suppositionsMatch;
 }
 
-function matchConsequent(consequent, statementNode, substitutions, proofContext, statementProofContext) {
-  const nonTerminalNodeMatches = consequent.matchStatementNode(statementNode, substitutions, proofContext, statementProofContext),
+function matchConsequent(consequent, statementNode, substitutions, localContext, statementLocalContext) {
+  const nonTerminalNodeMatches = consequent.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext),
         consequentMatches = nonTerminalNodeMatches; ///
 
   return consequentMatches;

package/src/collection.js

@@ -0,0 +1,101 @@
+"use strict";
+
+export default class Collection {
+  constructor(terms) {
+    this.terms = terms;
+  }
+
+  getTerms() {
+    return this.terms;
+  }
+
+  setTerms(terms) {
+    this.terms = terms;
+  }
+
+  addTerm(term) {
+    this.terms.push(term);
+  }
+
+  getType() {
+    const type = this.terms.reduce((type, term) => {
+      const termType = term.getType();
+
+      if (type === null) {
+        type = termType;  ///
+      } else {
+        const termTypeSubTypeOfType = termType.isSubTypeOf(type);
+
+        if (termTypeSubTypeOfType) {
+          type = termType;  ///
+        }
+      }
+
+      return type;
+    }, null);
+
+    return type;
+  }
+
+  matchType(type) {
+    const typeA = type; ///
+
+    type = this.getType();
+
+    const typeB = type; ///
+
+    const typeMatches = (typeA === typeB);  ///
+
+    return typeMatches;
+  }
+
+  matchTerm(term) {
+    const termA = term, ///
+          termMatches = this.terms.some((term) => {
+            const termB = term, ///
+                  termAMatchesTermB = termA.match(termB);
+
+            if (termAMatchesTermB) {
+              return true;
+            }
+          });
+
+    return termMatches;
+  }
+
+  matchTerms(terms) {
+    const termsMatch = terms.every((term) => {
+      const termMatches = this.matchTerm(term);
+
+      if (termMatches) {
+        return true;
+      }
+    })
+
+    return termsMatch;
+  }
+
+  static fromEquality(equality) {
+    const leftTerm = equality.getLeftTerm(),
+          rightTerm = equality.getRightTerm(),
+          terms = [
+            leftTerm,
+            rightTerm
+          ],
+          collection = new Collection(terms);
+
+    return collection;
+  }
+
+  static fromCollections(collectionA, collectionB) {
+    const collectionATerms = collectionA.getTerms(),
+          collectionBTerms = collectionB.getTerms(),
+          terms = [
+            ...collectionATerms,
+            ...collectionBTerms
+          ],
+          collection = new Collection(terms);
+
+    return collection;
+  }
+}

package/src/conclusion.js

@@ -15,12 +15,12 @@ export default class Conclusion {
     return this.metastatementNode;
   }
 
-  matchStatementNode(statementNode, substitutions, fileContext, statementProofContext) {
+  matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
           fileContextA = fileContext, ///
-          proofContextB = statementProofContext,  ///
-          nonTerminalNodeVerified = conclusionStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB, () => {
+          localContextB = statementLocalContext,  ///
+          nonTerminalNodeVerified = conclusionStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
             const verifyAhead = true;
 
             return verifyAhead;
@@ -30,12 +30,12 @@ export default class Conclusion {
     return statementNodeMatches;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementMetaproofContext) {
+  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementMetalocalContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
           fileContextA = fileContext, ///
-          metaproofContextB = metastatementMetaproofContext,  ///
-          nonTerminalNodeVerified = conclusionMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB, () => {
+          metalocalContextB = metastatementMetalocalContext,  ///
+          nonTerminalNodeVerified = conclusionMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metalocalContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/conjecture.js

@@ -5,5 +5,5 @@ import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
 export default class Conjecture extends AxiomLemmaTheoremConjecture {
   static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Conjecture, json, fileContext); }
 
-  static fromLabelsSuppositionsConsequentAndProofContext(labels, suppositions, consequent, proofContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequentAndProofContext(Conjecture, labels, suppositions, consequent, proofContext); }
+  static fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequentAndLocalContext(Conjecture, labels, suppositions, consequent, localContext); }
 }

package/src/consequent.js

@@ -14,12 +14,12 @@ export default class Consequent {
     return this.statementNode;
   }
 
-  matchStatementNode(statementNode, substitutions, proofContext) {
+  matchStatementNode(statementNode, substitutions, localContext) {
     const nonTerminalNodeA = this.statementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          proofContextA = proofContext, ///
-          proofContextB = null, ///
-          nonTerminalNodeVerified = consequentTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, () => {
+          localContextA = localContext, ///
+          localContextB = null, ///
+          nonTerminalNodeVerified = consequentTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/context/file.js

@@ -58,7 +58,9 @@ export default class FileContext {
 
   getParser() { return this.releaseContext.getParser(); }
 
-  getEqualities(equalities = []) {
+  getEqualities() {
+    const equalities = [];  ///
+
     return equalities;
   }
 
@@ -68,6 +70,12 @@ export default class FileContext {
     return proofSteps;
   }
 
+  getCollections() {
+    const collections = []; ///
+
+    return collections;
+  }
+
   getMetaproofSteps() {
     const metaproofSteps = [];  ///