occam-verify-cli 0.0.1065 → 0.0.1067

package/src/context/local.js

@@ -7,11 +7,12 @@ 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, variables, proofSteps, judgements, equivalences, metavariables) {
+  constructor(context, tokens, variables, proofSteps, judgements, equivalences, metavariables) {
     this.context = context;
+    this.tokens = tokens;
     this.variables = variables;
     this.proofSteps = proofSteps;
     this.judgements = judgements;
@@ -23,6 +24,10 @@ class LocalContext {
     return this.context;
   }
 
+  getTokens() {
+    return this.tokens;
+  }
+
   getVariables() {
     let variables = this.context.getVariables();
 
@@ -161,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;
@@ -227,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;
 
@@ -338,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;
@@ -365,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;
@@ -394,9 +377,47 @@ class LocalContext {
 
   findMetatheoremByReference(reference) { return this.context.findMetatheoremByReference(reference); }
 
-  nodeAsString(node) { return this.context.nodeAsString(node); }
+  nodeAsString(node, tokens = null) {
+    if (tokens === null) {
+      tokens = this.tokens;
+    }
+
+    const string = this.context.nodeAsString(node, tokens);
+
+    return string;
+  }
+
+  nodesAsString(node, tokens = null) {
+    if (tokens === null) {
+      tokens = this.tokens;
+    }
+
+    const string = this.context.nodesAsString(node, tokens);
+
+    return string;
+  }
+
+  nodeAsTokens(node, tokens = null) {
+    if (tokens === null) {
+      tokens = this.tokens;
+    }
+
+    tokens = this.context.nodeAsTokens(node, tokens); ///
+
+    return tokens;
+  }
+
+  nodesAsTokens(node, tokens = null) {
+    if (tokens === null) {
+      tokens = this.tokens;
+    }
 
-  nodesAsString(node) { return this.context.nodesAsString(node); }
+    tokens = this.context.nodesAsTokens(node, tokens);  ///
+
+    return tokens;
+  }
+
+  tokensAsString(tokens) { return this.context.tokensAsString(tokens); }
 
   trace(message, node) { this.context.trace(message, node); }
 
@@ -410,25 +431,40 @@ class LocalContext {
 
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
+          tokens = null,
           variables = [],
           proofSteps = [],
-          equivalences = [],
           judgements = [],
+          equivalences = [],
           metavariables = [],
-          localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables);
+          localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences, metavariables);
 
     return localContext;
   }
 
   static fromLocalContext(localContext) {
     const context = localContext,  ///
+          tokens = null,
           variables = [],
           proofSteps = [],
+          judgements = [],
           equivalences = [],
+          metavariables = [];
+
+    localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences, metavariables);  ///
+
+    return localContext;
+  }
+
+  static fromLocalContextAndTokens(localContext, tokens) {
+    const context = localContext,  ///
+          variables = [],
+          proofSteps = [],
           judgements = [],
+          equivalences = [],
           metavariables = [];
 
-    localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, 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 BracketedCombinator from "../../ocmbinator/bracketed";
+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,7 +6,6 @@ import TypeAssertion from "../../assertion/type";
 import DefinedAssertion from "../../assertion/defined";
 import SubproofAssertion from "../../assertion/subproof";
 import ContainedAssertion from "../../assertion/contained";
-import StatementSubstitution from "../../substitution/statement";
 
 import verifyFrame from "../../verify/frame";
 import verifyJudgement from "../../verify/judgement";
@@ -38,19 +37,7 @@ function verifyAsMetavariable(statement, assignments, stated, localContext) {
 
     const metavariableVerified = metavariable.verify(localContext);
 
-    if (metavariableVerified) {
-      let substitutionVerified = true;
-
-      const statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext);
-
-      if (statementSubstitution !== null) {
-        const statementSubstitutionVerified = statementSubstitution.verify(assignments, stated, localContext);
-
-        substitutionVerified = statementSubstitutionVerified; ///
-      }
-
-      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/ruleNames.js

@@ -2,6 +2,5 @@
 
 export const VARIABLE_RULE_NAME = "variable";
 export const METAVARIABLE_RULE_NAME = "metavariable";
-export const SUBSTITUTION_RULE_NAME = "substitution";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";

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;