occam-verify-cli 0.0.1066 → 0.0.1067

package/src/context/file.js

@@ -520,10 +520,9 @@ export default class FileContext {
   }
 
   findVariableByVariableName(variableName) {
-    const name = variableName,  ///
-          variables = this.getVariables(),
+    const variables = this.getVariables(),
           variable = variables.find((variable) => {
-            const nameMatches = variable.matchName(name);
+            const nameMatches = variable.matchVariableName(variableName);
 
             if (nameMatches) {
               return true;
@@ -547,10 +546,9 @@ export default class FileContext {
   }
 
   findMetavariableByMetavariableName(metavariableName) {
-    const name = metavariableName,  ///
-          metavariables = this.getMetavariables(),
+    const metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const nameMatches = metavariable.matchName(name);
+            const nameMatches = metavariable.matchMetavariableName(metavariableName);
 
             if (nameMatches) {
               return true;
@@ -625,9 +623,9 @@ export default class FileContext {
   addVariable(variable) {
     let variableAdded = false;
 
-    const node = variable.getNode(),
+    const variableNode = variable.getNode(),
           variablePresent = this.variables.some((variable) => {
-            const variableMatchesNode = variable.matchNode(node);
+            const variableMatchesNode = variable.matchVariableNode(variableNode);
 
             if (variableMatchesNode) {
               return true;

package/src/context/local.js

@@ -7,7 +7,7 @@ import Equivalence from "../equivalence";
 import { metavariableNameFromMetavariableNode } from "../utilities/name";
 import { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariablesFromFromEquivalences } from "../utilities/equivalences";
 
-const { last, reverse } = arrayUtilities;
+const { last } = arrayUtilities;
 
 class LocalContext {
   constructor(context, tokens, variables, proofSteps, judgements, equivalences, metavariables) {
@@ -166,9 +166,9 @@ class LocalContext {
   addVariable(variable) {
     let variableAdded = false;
 
-    const node = variable.getNode(),
+    const variableNode = variable.getNode(),
           variablePresent = this.variables.some((variable) => {
-            const variableMatchesNode = variable.matchNode(node);
+            const variableMatchesNode = variable.matchVariableNode(variableNode);
 
             if (variableMatchesNode) {
               return true;
@@ -232,26 +232,6 @@ class LocalContext {
     return metavariableAdded;
   }
 
-  unifyStatement(statementNode, localContext) {
-    let proofSteps = this.getProofSteps();
-
-    proofSteps = reverse(proofSteps); ///
-
-    const equivalences = this.getEquivalences(),
-          localContextA = this,  ///
-          localContextB = localContext, ///
-          statementNodeB = statementNode, ///
-          statementUnified = proofSteps.some((proofStep) => {
-            const statementUnified = proofStep.unifyStatement(statementNodeB, equivalences, localContextA, localContextB);
-
-            if (statementUnified) {
-              return true;
-            }
-          });
-
-    return statementUnified;
-  }
-
   getTermType(term) {
     let termType;
 
@@ -343,10 +323,9 @@ class LocalContext {
   findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
   findVariableByVariableName(variableName) {
-    const name = variableName,  ///
-          variables = this.getVariables(),
+    const variables = this.getVariables(),
           variable = variables.find((variable) => {
-            const nameMatches = variable.matchName(name);
+            const nameMatches = variable.matchVariableName(variableName);
 
             if (nameMatches) {
               return true;
@@ -370,10 +349,9 @@ class LocalContext {
   }
 
   findMetavariableByMetavariableName(metavariableName) {
-    const name = metavariableName,  ///
-          metavariables = this.getMetavariables(),
+    const metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const nameMatches = metavariable.matchName(name);
+            const nameMatches = metavariable.matchMetavariableName(metavariableName);
 
             if (nameMatches) {
               return true;
@@ -478,14 +456,15 @@ class LocalContext {
     return localContext;
   }
 
-  static fromFileContextAndTokens(fileContext, tokens) {
-    const context = fileContext,  ///
+  static fromLocalContextAndTokens(localContext, tokens) {
+    const context = localContext,  ///
           variables = [],
           proofSteps = [],
           judgements = [],
           equivalences = [],
-          metavariables = [],
-          localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences, metavariables);  ///
+          metavariables = [];
+
+    localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences, metavariables);  ///
 
     return localContext;
   }

package/src/metavariable.js

@@ -50,10 +50,10 @@ class Metavariable {
     return metaTypeName;
   }
 
-  matchName(name) {
-    const nameMatches = (this.name === name);
+  matchMetavariableName(metavariableName) {
+    const metavariableNameMatches = (this.name === metavariableName);
 
-    return nameMatches;
+    return metavariableNameMatches;
   }
 
   matchMetavariableNode(metavariableNode) {
@@ -125,21 +125,29 @@ class Metavariable {
     return verifiedAtTopLevel;
   }
 
-  unifyStatement(statement, substitutions, localContext) {
+  unifyStatement(statement, substitution, substitutions, localContext) {
     let statementUnified = false;
 
     const statementString = statement.getString(),
-          metavariableString = this.string; ///
+          metavariableString = this.string, ///
+          substitutionString = (substitution !== null) ?
+                                  substitution.getString() :
+                                    null;
 
-    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable...`);
+    (substitutionString !== null) ?
+      localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable given the ${substitutionString} substitution...`) :
+        localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable...`);
 
     const statementNode = statement.getNode(),
           metavariableNode = this.node, ///
-          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode),
-          substitution = simpleSubstitution;  ///
+          substitutionNode = (substitution !== null) ?
+                               substitution.getSubstitutionNode() :
+                                 null,
+          substitutionPresent = substitutions.isSubstitutionPresentByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
 
-    if (substitution !== null) {
-      const statementNodeMatches = substitution.matchStatementNode(statementNode);
+    if (substitutionPresent) {
+      const substitution = substitutions.findSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode),
+            statementNodeMatches = substitution.matchStatementNode(statementNode);
 
       if (statementNodeMatches) {
         statementUnified = true;
@@ -151,64 +159,21 @@ class Metavariable {
       if (metavariable === statementMetavariable) {
         statementUnified = true;
       } else {
-        const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, localContext),
-              substitution = statementForMetavariableSubstitution;  ///
-
-        substitutions.addSubstitution(substitution, localContext);
-
-        statementUnified = true;
-      }
-    }
-
-    if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable.`);
-    }
-
-    return statementUnified;
-  }
-
-  unifyStatementGivenSubstitution(statement, substitution, substitutions, localContext) {
-    let statementUnifiedGivenSubstitution = false;
-
-    const statementString = statement.getString(),
-          substitutionString = substitution.getString(),
-          metavariableString = this.string; ///
-
-    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable given the '${substitutionString}' substitution...`);
-
-    const statementNode = statement.getNode(),
-          metavariableNode = this.node, ///
-          substitutionNode = substitution.getNode(),
-          complexSubstitution = substitutions.findComplexSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
-
-    if (complexSubstitution !== null) {
-      const statementNodeMatches = complexSubstitution.matchStatementNode(statementNode);
-
-      if (statementNodeMatches) {
-        statementUnifiedGivenSubstitution = true;
-      }
-    } else {
-      const metavariable = metavariableFromStatementNode(statementNode, localContext);
-
-      if (this === metavariable) {  ///
-        statementUnifiedGivenSubstitution = false;  ///
-      } else {
-        const metavariable = this,  ///
-              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
+        const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
 
         substitution = statementForMetavariableSubstitution;  ///
 
         substitutions.addSubstitution(substitution, localContext);
 
-        statementUnifiedGivenSubstitution = true;
+        statementUnified = true;
       }
     }
 
-    if (statementUnifiedGivenSubstitution) {
-      localContext.trace(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable given the '${substitutionString}' substitution.`);
-    }
+    (substitutionString !== null) ?
+      localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable given the ${substitutionString} substitution.`) :
+        localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable.`);
 
-    return statementUnifiedGivenSubstitution;
+    return statementUnified;
   }
 
   toJSON() {
@@ -292,21 +257,6 @@ function metaTypeFromJSON(json, fileContext) {
   return metaType;
 }
 
-function metavariableFromStatementNode(statementNode, localContext) {
-  let metavariable = null;
-
-  const statementMetavariableNode = statementMetavariableNodeQuery(statementNode)
-
-  if (statementMetavariableNode !== null) {
-    const metavariableNode = statementMetavariableNode, ///
-          metavariableName = metavariableNameFromMetavariableNode(metavariableNode);
-
-    metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
-  }
-
-  return metavariable;
-}
-
 function statementMetavariableFromStatementNode(statementNode, localContext) {
   let statementMetavariable = null;
 

package/src/mixins/statement/unify.js

@@ -1,8 +1,12 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import BracketedCombinator from "../../combinator/bracketed";
 import statementWithCombinatorUnifier from "../../unifier/statementWithCombinator";
 
+const { reverse } = arrayUtilities;
+
 function unifyWithBracketedCombinator(statement, assignments, stated, localContext) {
   let unifiedWithBracketedCombinator;
 
@@ -43,9 +47,28 @@ function unifyWithCombinators(statement, assignments, stated, localContext) {
   return unifiedWithCombinators;
 }
 
+function unifyWithProofSteps(statement, assignments, stated, localContext) {
+  let unifiedWithProofSteps;
+
+  let proofSteps = localContext.getProofSteps();
+
+  proofSteps = reverse(proofSteps); ///
+
+  unifiedWithProofSteps = proofSteps.some((proofStep) => {
+    const statementUnified = proofStep.unifyStatement(statement, localContext);
+
+    if (statementUnified) {
+      return true;
+    }
+  });
+
+  return unifiedWithProofSteps;
+}
+
 const unifyMixins = [
   unifyWithBracketedCombinator,
-  unifyWithCombinators
+  unifyWithCombinators,
+  unifyWithProofSteps
 ];
 
 export default unifyMixins;

package/src/mixins/statement/verify.js

@@ -6,8 +6,6 @@ import TypeAssertion from "../../assertion/type";
 import DefinedAssertion from "../../assertion/defined";
 import SubproofAssertion from "../../assertion/subproof";
 import ContainedAssertion from "../../assertion/contained";
-import TermForVariableSubstitution from "../../substitution/termForVariable";
-import FrameForMetavariableSubstitution from "../../substitution/frameForMetavariable";
 
 import verifyFrame from "../../verify/frame";
 import verifyJudgement from "../../verify/judgement";
@@ -39,19 +37,7 @@ function verifyAsMetavariable(statement, assignments, stated, localContext) {
 
     const metavariableVerified = metavariable.verify(localContext);
 
-    if (metavariableVerified) {
-      let substitutionVerified = true;
-
-      const substitution = FrameForMetavariableSubstitution.fromStatementNode(statementNode, localContext) ||
-                             TermForVariableSubstitution.fromStatementNode(statementNode, localContext) ||
-                               null;
-
-      if (substitution !== null) {
-        substitutionVerified = substitution.verify(assignments, stated, localContext);
-      }
-
-      verifiedAsMetavariable = substitutionVerified; ///
-    }
+    verifiedAsMetavariable = metavariableVerified; ///
 
     if (verifiedAsMetavariable) {
       localContext.debug(`...verified the '${statementString}' statement as a metavariable.`);

package/src/premise.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import shim from "./shim";
+import LocalContext from "./context/local";
 import SubproofAssertion from "./assertion/subproof";
 import UnqualifiedStatement from "./statement/unqualified";
 
@@ -83,7 +84,13 @@ export default class Premise {
 
     localContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
 
-    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, this.fileContext, localContext);
+    const localContextB = localContext;
+
+    localContext = LocalContext.fromFileContext(this.fileContext);
+
+    const localContextA = localContext; ///
+
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
     if (statementUnified) {
       localContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);

package/src/proofStep.js

@@ -2,6 +2,7 @@
 
 import shim from "./shim";
 import Subproof from "./subproof";
+import Substitutions from "./substitutions";
 import QualifiedStatement from "./statement/qualified";
 import UnqualifiedStatement from "./statement/unqualified";
 
@@ -44,18 +45,33 @@ class ProofStep {
     return statement;
   }
 
-  // unifyStatement(statementB, equivalences, localContextA, localContextB) {
-  //   let statementUnified = false;
-  //
-  //   if (this.statement !== null) {
-  //     const statementA = this.statement,  ///
-  //           statementUnifiedWithStatement = unifyStatementWithStatementGivenEquivalences(statementA, statementB, equivalences, localContextA, localContextB);
-  //
-  //     statementUnified = statementUnifiedWithStatement;  ///
-  //   }
-  //
-  //   return statementUnified;
-  // }
+  unifyStatement(statement, localContext) {
+    let statementUnified = false;
+
+    const substitutions = Substitutions.fromNothing();
+
+    if (this.qualifiedStatement !== null) {
+      const localContextA = localContext, ///
+            localContextB = localContext; ///
+
+      statementUnified = this.qualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+    }
+
+    if (this.unqualifiedStatement !== null) {
+      const localContextA = localContext, ///
+            localContextB = localContext; ///
+
+      statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+    }
+
+    const substitutionsLength = substitutions.getLength();
+
+    if (substitutionsLength > 0) {
+      statementUnified = false;
+    }
+
+    return statementUnified;
+  }
 
   verify(substitutions, localContext) {
     let verified = false;

package/src/rule.js

@@ -67,7 +67,13 @@ export default class Rule {
           proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
 
     if (proofStepsUnified) {
-      statementUnified = this.conclusion.unifyStatement(statement, substitutions, localContext);
+      const statementUnifiedWithConclusion = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
+
+      if (statementUnifiedWithConclusion) {
+        const substitutionsResolved = substitutions.resolve(localContext);
+
+        statementUnified = substitutionsResolved; ///
+      }
     }
 
     return statementUnified;

package/src/statement/qualified.js

@@ -33,6 +33,44 @@ export default class QualifiedStatement {
 
   getMetavariableNode() { return this.reference.getMetavariableNode(); }
 
+  unify(substitutions, localContext) {
+    let unified;
+
+    const qualifiedStatement = this,  ///
+          qualifiedStatementString = this.string; ///
+
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement...`);
+
+    unified = unifyMixins.some((unifyMixin) => {
+      const unified = unifyMixin(qualifiedStatement, substitutions, localContext);
+
+      return unified;
+    });
+
+    if (unified) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement.`);
+    }
+
+    return unified;
+  }
+
+  unifyStatement(statement, substitutions, localContextA, localContextB) {
+    let statementUnified;
+
+    const statementString = statement.getString(),
+          unqualifiedStatementString = this.getString();  ///
+
+    localContextB.trace(`Unifying the '${statementString}' statement with the '${unqualifiedStatementString}' qualified statement...`);
+
+    statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
+
+    if (statementUnified) {
+      localContextB.debug(`...unified the '${statementString}' statement with the '${unqualifiedStatementString}' qualified statement.`);
+    }
+
+    return statementUnified;
+  }
+
   verify(substitutions, localContext) {
     let verified;
 
@@ -65,27 +103,6 @@ export default class QualifiedStatement {
     return verified;
   }
 
-  unify(substitutions, localContext) {
-    let unified;
-
-    const qualifiedStatement = this,  ///
-          qualifiedStatementString = this.string; ///
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement...`);
-
-    unified = unifyMixins.some((unifyMixin) => {
-      const unified = unifyMixin(qualifiedStatement, substitutions, localContext);
-
-      return unified;
-    });
-
-    if (unified) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement.`);
-    }
-
-    return unified;
-  }
-
   static fromQualifiedStatementNode(qualifiedStatementNode, fileContext) {
     let qualifiedStatement = null;
 

package/src/statement/unqualified.js

@@ -45,18 +45,18 @@ export default class UnqualifiedStatement {
     return verified;
   }
 
-  unifyStatement(statement, substitutions, fileContext, localContext) {
+  unifyStatement(statement, substitutions, localContextA, localContextB) {
     let statementUnified;
 
     const statementString = statement.getString(),
           unqualifiedStatementString = this.getString();  ///
 
-    localContext.trace(`Unifying the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement...`);
+    localContextB.trace(`Unifying the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement...`);
 
-    statementUnified = this.statement.unifyStatement(statement, substitutions, fileContext, localContext);
+    statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement.`);
+      localContextB.debug(`...unified the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement.`);
     }
 
     return statementUnified;

package/src/statement.js

@@ -51,7 +51,7 @@ class Statement {
     const variableString = variable.getString(),
           statementString = this.string;  ///
 
-    localContext.trace(`The '${variableString}' variable is contained in hte '${statementString}' statement...`);
+    localContext.trace(`Is the '${variableString}' variable contained in the '${statementString}' statement...`);
 
     const variableNode = variable.getNode(),
           statementNode = this.node,
@@ -66,7 +66,7 @@ class Statement {
     });
 
     if (variableContained) {
-      localContext.debug(`...the '${variableString}' variable is contained in hte '${statementString}' statement.`);
+      localContext.debug(`...the '${variableString}' variable is contained in the '${statementString}' statement.`);
     }
 
     return variableContained;
@@ -78,7 +78,7 @@ class Statement {
     const metavariableString = metavariable.getString(),
           statementString = this.string;  ///
 
-    localContext.trace(`The '${metavariableString}' metavariable is contained in hte '${statementString}' statement...`);
+    localContext.trace(`Is the '${metavariableString}' metavariable contained in the '${statementString}' statement...`);
 
     const metavariableNode = metavariable.getNode(),
           statementNode = this.node,
@@ -93,13 +93,19 @@ class Statement {
     });
 
     if (metavariableContained) {
-      localContext.debug(`...the '${metavariableString}' metavariable is contained in hte '${statementString}' statement.`);
+      localContext.debug(`...the '${metavariableString}' metavariable is contained in the '${statementString}' statement.`);
     }
 
     return metavariableContained;
   }
 
-  unifyStatement(statement, substitutions, fileContext, localContext) {
+  matchStatementNode(statementNode) {
+    const statementNodeMatches = this.node.match(statementNode);
+
+    return statementNodeMatches;
+  }
+
+  unifyStatement(statement, substitutions, localContextA, localContextB) {
     let statementUnified;
 
     const statementA = this,  ///
@@ -107,20 +113,20 @@ class Statement {
           statementAString = statementA.getString(),
           statementBString = statementB.getString();
 
-    localContext.trace(`Unifying the '${statementBString}' statement with the '${statementAString}' statement...`);
+    localContextB.trace(`Unifying the '${statementBString}' statement with the '${statementAString}' statement...`);
 
     const statementANode = statementA.getNode(),
           statementBNode = statementB.getNode(),
           nodeA = statementANode, ///
-          nodeB = statementBNode, ///
-          fileContextA = fileContext, ///
-          localContextA = LocalContext.fromFileContextAndTokens(fileContextA, this.tokens),
-          localContextB = localContext, ///
-          unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+          nodeB = statementBNode; ///
+
+    localContextA = LocalContext.fromLocalContextAndTokens(localContextA, this.tokens);
+
+    const unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
     statementUnified = unifiedAtMetaLevel; ///
 
-    localContext.debug(`...unified the '${statementBString}' statement with the '${statementAString}' statement.`);
+    localContextB.debug(`...unified the '${statementBString}' statement with the '${statementAString}' statement.`);
 
     return statementUnified;
   }

package/src/subproof.js

@@ -51,7 +51,6 @@ export default class Subproof {
     return statements;
   }
 
-
   verify(substitutions, localContext) {
     let subproofVerified = false;