occam-verify-cli 0.0.682 → 0.0.684

package/src/context/local.js

@@ -0,0 +1,311 @@
+"use strict";
+
+import Variable from "../variable";
+import Equality from "../equality";
+import Collection from "../collection";
+import fileMixins from "../mixins/file";
+import loggingMixins from "../mixins/logging";
+
+import { last, filter } from "../utilities/array";
+import { mergeCollections, findCollectionByType, findCollectionByTerm, findCollectionByTerms } from "../utilities/collection";
+
+class LocalContext {
+  constructor(context, variables, proofSteps, collections) {
+    this.context = context;
+    this.variables = variables;
+    this.proofSteps = proofSteps;
+    this.collections = collections;
+  }
+
+  getContext() {
+    return this.context;
+  }
+
+  getVariables() {
+    let variables = this.context.getVariables();
+
+    variables = [ ///
+      ...variables,
+      ...this.variables
+    ];
+
+    return variables;
+  }
+
+  getProofSteps() {
+    let proofSteps = this.context.getProofSteps();
+
+    proofSteps = [  ///
+      ...proofSteps,
+      ...this.proofSteps
+    ];
+
+    return proofSteps;
+  }
+
+  getCollections() {
+    let collections = this.context.getCollections();
+
+    const collectionsA = collections, ///
+          collectionsB = this.collections;
+
+    collections = mergeCollections(collectionsA, collectionsB); ///
+
+    return collections;
+  }
+
+  getEqualities() {
+    const equalities = this.context.getEqualities();
+
+    this.proofSteps.forEach((proofStep) => {
+      const equality = Equality.fromProofStep(proofStep);
+
+      if (equality !== null) {
+        equalities.push(equality);
+      }
+    });
+
+    return equalities;
+  }
+
+  getLastProofStep() {
+    let lastProofStep = null;
+
+    const proofStepsLength = this.proofSteps.length;
+
+    if (proofStepsLength > 0) {
+      lastProofStep = last(this.proofSteps);
+    }
+
+    return lastProofStep;
+  }
+
+  getMetavariables() { return this.context.getMetavariables(); }
+
+  addEquality(equality) {
+    const equalityReflexive = equality.isReflexive();
+
+    if (equalityReflexive) {
+      ///
+    } else {
+      const leftTerm = equality.getLeftTerm(),
+            rightTerm = equality.getRightTerm(),
+            leftCollection = this.findCollectionByTerm(leftTerm),
+            rightCollection = this.findCollectionByTerm(rightTerm);
+
+      if (false) {
+        ///
+      } else if ((leftCollection === null) && (rightCollection === null)) {
+        const collection = Collection.fromEquality(equality);
+
+        this.addCollection(collection);
+      } else if ((leftCollection !== null) && (rightCollection === null)) {
+        const term = rightTerm, ///
+              collection = leftCollection;  ///
+
+        collection.addTerm(term);
+      } else if ((leftCollection === null) && (rightCollection !== null)) {
+        const term = leftTerm, ///
+              collection = rightCollection;  ///
+
+        collection.addTerm(term);
+      } else if ((leftCollection !== null) && (rightCollection !== null)) {
+
+        debugger
+
+      }
+    }
+  }
+
+  addVariable(variable) {
+    const variableName = variable.getName();
+
+    filter(this.variables, (variable) => {
+      const name = variable.getName(),
+            nameVariableName = (name === variableName);
+
+      if (!nameVariableName) {
+        return true;
+      }
+    });
+
+    this.variables.push(variable);
+  }
+
+  addProofStep(proofStep) {
+    this.proofSteps.push(proofStep);
+  }
+
+  addCollection(collection) {
+    this.collections.push(collection);
+  }
+
+  matchStatement(statementNode) {
+    let statementMatches = false;
+
+    if (!statementMatches) {
+      const proofStepMatchesStatement = this.proofSteps.some((proofStep) => {
+        const proofStepMatchesStatement = proofStep.match(statementNode);
+
+        if (proofStepMatchesStatement) {
+          return true;
+        }
+      });
+
+      statementMatches = proofStepMatchesStatement; ///
+    }
+
+    if (!statementMatches) {
+      statementMatches = this.context.matchStatement(statementNode);
+    }
+
+    return statementMatches;
+  }
+
+  findCollectionByType(type) {
+    const collections = this.getCollections(),
+          collection = findCollectionByType(collections, type);
+
+    return collection;
+  }
+
+  findCollectionByTerm(term) {
+    const collections = this.getCollections(),
+          collection = findCollectionByTerm(collections, term);
+
+    return collection;
+  }
+
+  findCollectionByTerms(terms) {
+    const collections = this.getCollections(),
+          collection = findCollectionByTerms(collections, terms);
+
+    return collection;
+  }
+
+  findVariableByVariableName(variableName) {
+    const name = variableName,  ///
+          variables = this.getVariables(),
+          variable = variables.find((variable) => {
+            const matches = variable.matchName(name);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return variable;
+  }
+
+  isVariablePresentByVariableName(variableName) {
+    const variable = this.findVariableByVariableName(variableName),
+          variablePresent = (variable !== null);
+
+    return variablePresent;
+  }
+
+  isEqualityEqual(equality) {
+    let equalityEqual;
+
+    const equalityReflexive = equality.isReflexive();
+
+    if (equalityReflexive) {
+      equalityEqual = true;
+    } else {
+      const leftTerm = equality.getLeftTerm(),
+            rightTerm = equality.getRightTerm(),
+            terms = [
+              leftTerm,
+              rightTerm
+            ],
+            termsEqual = this.areTermsEqual(terms);
+
+      equalityEqual = termsEqual; ///
+    }
+
+    return equalityEqual;
+  }
+
+  areTermsEqual(terms) {
+    const collection = this.findCollectionByTerms(terms),
+          termsEqual = (collection !== null);
+
+    return termsEqual;
+  }
+
+  toJSON(tokens) {
+    const variables = this.variables.map((variable) => {
+            const variableJSON = variable.toJSON(tokens);
+
+            variable = variableJSON;
+
+            return variable;
+          }),
+          json = {
+            variables
+          };
+
+    return json;
+  }
+
+  static fromFileContext(fileContext) {
+    const context = fileContext,  ///
+          variables = [],
+          proofSteps = [],
+          collections = [],
+          localContext = new LocalContext(context, variables, proofSteps, collections);
+
+    return localContext;
+  }
+
+  static fromLocalContext(localContext) {
+    const context = localContext,  ///
+          variables = [],
+          proofSteps = [],
+          collections = [];
+
+    localContext = new LocalContext(context, variables, proofSteps, collections);
+
+    return localContext;
+  }
+
+  static fromJSONAndFileContext(json, fileContext) {
+    let { variables } = json;
+
+    const variablesJSON = variables;
+
+    variables = variablesJSON.map((variableJSON) => {
+      const json = variableJSON,  ///
+            variable = Variable.fromJSONAndFileContext(json, fileContext);
+
+      return variable;
+    });
+
+    const context = fileContext,  ///
+          proofSteps = [],
+          collections = [],
+          localContext = new LocalContext(context, variables, proofSteps, collections);
+
+    return localContext;
+  }
+
+  static fromLocalContextAndAssignments(localContext, assignments) {
+    const context = localContext,  ///
+          variables = assignments.map((assignment) => {
+            const variable = assignment.getVariable();
+
+            return variable;
+          }),
+          proofSteps = [],
+          collections = [];
+
+    localContext = new LocalContext(context, variables, proofSteps, collections);
+
+    return localContext;
+  }
+}
+
+Object.assign(LocalContext.prototype, fileMixins);
+Object.assign(LocalContext.prototype, loggingMixins);
+
+export default LocalContext;

package/src/context/{metaproof.js → localMeta.js}

@@ -3,9 +3,9 @@
 import fileMixins from "../mixins/file";
 import loggingMixins from "../mixins/logging";
 
-import { push, last, filter } from "../utilities/array";
+import { last, filter } from "../utilities/array";
 
-class MetaproofContext {
+class LocalMetaContext {
   constructor(context, metavariables, metaproofSteps) {
     this.context = context;
     this.metavariables = metavariables;
@@ -17,13 +17,12 @@ class MetaproofContext {
   }
 
   getMetavariables() {
-    const metavariables = [];
+    let metavariables = this.context.getMetavariables();
 
-    push(metavariables, this.metavariables);
-
-    const contextMetavariables = this.context.getMetavariables();
-
-    push(metavariables, contextMetavariables);
+    metavariables = [ ///
+      ...metavariables,
+      this.metavariables
+    ]
 
     return metavariables;
   }
@@ -119,23 +118,23 @@ class MetaproofContext {
     const context = fileContext,  ///
           metavariables = [],
           metaproofSteps = [],
-          metaproofContext = new MetaproofContext(context, metavariables, metaproofSteps);
+          localMetaContext = new LocalMetaContext(context, metavariables, metaproofSteps);
 
-    return metaproofContext;
+    return localMetaContext;
   }
 
-  static fromMetaproofContext(metaproofContext) {
-    const context = metaproofContext,  ///
+  static fromLocalMetaContext(localMetaContext) {
+    const context = localMetaContext,  ///
           metavariables = [],
           metaproofSteps = [];
 
-    metaproofContext = new MetaproofContext(context, metavariables, metaproofSteps);  ///
+    localMetaContext = new LocalMetaContext(context, metavariables, metaproofSteps);  ///
 
-    return metaproofContext;
+    return localMetaContext;
   }
 }
 
-Object.assign(MetaproofContext.prototype, fileMixins);
-Object.assign(MetaproofContext.prototype, loggingMixins);
+Object.assign(LocalMetaContext.prototype, fileMixins);
+Object.assign(LocalMetaContext.prototype, loggingMixins);
 
-export default MetaproofContext;
+export default LocalMetaContext;

package/src/equality.js

@@ -1,131 +1,37 @@
 "use strict";
 
-import equalityNodesVerifier from "./verifier/nodes/equality";
-
-import { nodeQuery } from "./utilities/query";
-
-const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      leftTermNodeQuery = nodeQuery("/equality/argument[0]/term!"),
-      rightTermNodeQuery = nodeQuery("/equality/argument[1]/term!");
-
 export default class Equality {
-  constructor(leftTermNode, rightTermNode) {
-    this.leftTermNode = leftTermNode;
-    this.rightTermNode = rightTermNode;
-  }
-
-  getLeftTermNode() {
-    return this.leftTermNode;
+  constructor(leftTerm, rightTerm) {
+    this.leftTerm = leftTerm;
+    this.rightTerm = rightTerm;
   }
 
-  getRightTermNode() {
-    return this.rightTermNode;
+  getLeftTerm() {
+    return this.leftTerm;
   }
 
-  matchTermNodes(leftTermNode, rightTermNode, reversed, equalities, context) {
-    let termNodesMatch = true;
-
-    if (termNodesMatch) {
-      const leftNonTerminalNode = reversed ?
-                                    this.rightTermNode :
-                                      this.leftTermNode,  ///
-            rightNonTerminalNode = leftTermNode,  ///
-            nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context);
-
-      termNodesMatch = nonTerminalNodeVerified; ///
-    }
-
-    if (termNodesMatch) {
-      const leftNonTerminalNode = reversed ?
-                                    this.leftTermNode :
-                                      this.rightTermNode,  ///
-            rightNonTerminalNode = rightTermNode,  ///
-            nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context);
-
-      termNodesMatch = nonTerminalNodeVerified; ///
-    }
-
-    return termNodesMatch;
+  getRightTerm() {
+    return this.rightTerm;
   }
 
-  match(equality, equalities, context) {
-    let matches = false;
-
-    const leftTermNode = equality.getLeftTermNode(),
-          rightTermNode = equality.getRightTermNode();
-
-    equalities = filterEqualities(equalities, equality);  ///
-
-    if (!matches) {
-      const reversed = false,
-            leftTermNodeAndRightTermNodeMatch = this.matchTermNodes(leftTermNode, rightTermNode, reversed, equalities, context);
-
-      matches = leftTermNodeAndRightTermNodeMatch;  ///
-    }
-
-    if (!matches) {
-      const reversed = true,
-            leftTermNodeAndRightTermNodeMatch = this.matchTermNodes(leftTermNode, rightTermNode, reversed, equalities, context);
-
-      matches = leftTermNodeAndRightTermNodeMatch;  ///
-    }
+  isReflexive() {
+    const leftTermMatchesRightTerm = this.leftTerm.match(this.rightTerm),
+          reflexive = leftTermMatchesRightTerm;
 
-    return matches;
+    return reflexive;
   }
 
-  verify(equalities, context, verifyAhead) {
-    const leftNonTerminalNode = this.leftTermNode,  ///
-          rightNonTerminalNode = this.rightTermNode,  ///
-          nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context, verifyAhead),
-          verified = nonTerminalNodeVerified; ///
-
-    return verified;
-  }
-
-  static fromProofStep(proofStep) {
+  static fromLeftTermAndRightTerm(leftTerm, rightTerm) {
     let equality = null;
 
-    const statementNode = proofStep.getStatementNode();
-
-    if (statementNode !== null) {
-      const equalityNode = equalityNodeQuery(statementNode);
-
-      if (equalityNode !== null) {
-        const leftTermNode = leftTermNodeQuery(statementNode),
-              rightTermNode = rightTermNodeQuery(statementNode);
+    const leftTermType = leftTerm.getType(),
+          rightTermType = rightTerm.getType(),
+          leftTermTypeEqualToSubTypeOfOrSuperTypeOfRightTermType = leftTermType.isEqualToSubTypeOfOrSuperTypeOf(rightTermType);
 
-        equality = new Equality(leftTermNode, rightTermNode);
-      }
+    if (leftTermTypeEqualToSubTypeOfOrSuperTypeOfRightTermType) {
+      equality = new Equality(leftTerm, rightTerm);
     }
 
     return equality;
   }
-
-  static fromEqualityNode(equalityNode) {
-    const leftTermNode = leftTermNodeQuery(equalityNode),
-          rightTermNode = rightTermNodeQuery(equalityNode),
-          equality = new Equality(leftTermNode, rightTermNode);
-
-    return equality;
-  }
-
-  static fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode) {
-    const equality = new Equality(leftTermNode, rightTermNode);
-
-    return equality;
-  }
-}
-
-function filterEqualities(equalities, equality) {
-  const equalityA = equality; ///
-
-  equalities = equalities.filter((equality) => {
-    const equalityB = equality; ///
-
-    if (equalityA !== equalityB) {
-      return true;
-    }
-  });
-
-  return equalities;
 }

package/src/lemma.js

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

package/src/premise.js

@@ -23,7 +23,7 @@ export default class Premise {
     return this.metastatementNode;
   }
 
-  matchSubproofNode(subproofNode, substitutions, fileContext, statementProofContext) {
+  matchSubproofNode(subproofNode, substitutions, fileContext, statementLocalContext) {
     let subproofNodeMatches = false;
 
     const subproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
@@ -45,8 +45,8 @@ export default class Premise {
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
                 fileContextA = fileContext, ///
-                proofContextB = statementProofContext,  ///
-                nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB, () => {
+                localContextB = statementLocalContext,  ///
+                nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -62,12 +62,12 @@ export default class Premise {
     return subproofNodeMatches;
   }
 
-  matchStatementNode(statementNode, substitutions, fileContext, statementProofContext) {
+  matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
           fileContextA = fileContext, ///
-          proofContextB = statementProofContext,  ///
-          nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB, () => {
+          localContextB = statementLocalContext,  ///
+          nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
@@ -77,7 +77,7 @@ export default class Premise {
     return statementNodeMatches;
   }
 
-  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementMetaproofContext) {
+  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementMetalocalContext) {
     let ruleSubproofNodeMatches = false;
 
     const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
@@ -99,8 +99,8 @@ export default class Premise {
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
-                metaproofContextB = metastatementMetaproofContext,  ///
-                nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB, () => {
+                metalocalContextB = metastatementMetalocalContext,  ///
+                nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metalocalContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -116,12 +116,12 @@ export default class Premise {
     return ruleSubproofNodeMatches;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementMetaproofContext) {
+  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementMetalocalContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
           fileContextA = fileContext, ///
-          metaproofContextB = metastatementMetaproofContext,  ///
-          nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB, () => {
+          metalocalContextB = metastatementMetalocalContext,  ///
+          nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metalocalContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;