occam-verify-cli 0.0.1074 → 0.0.1077

package/src/metavariable.js

@@ -2,11 +2,11 @@
 
 import shim from "./shim";
 import LocalContext from "./context/local";
-import metavariableUnifier from "./unifier/metavariable";
 import FrameForMetavariableSubstitution from "./substitution/frameForMetavariable";
 import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
 import { nodeQuery } from "./utilities/query";
+import { EMPTY_STRING } from "./constants";
 import { metavariableNodeFromMetavariableString } from "./utilities/node";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "./utilities/json";
 import { typeNameFromTypeNode, metavariableNameFromMetavariableNode } from "./utilities/name";
@@ -80,11 +80,11 @@ class Metavariable {
 
     localContext.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
-    const metavariableName = this.name, ///
-          simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariableName(metavariableName);
+    const metavariableNode = this.node, ///
+          simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariableNode(metavariableNode);
 
     if (simpleSubstitutionPresent) {
-      const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableName(metavariableName),
+      const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode),
             substitution = simpleSubstitution,  ///
             frameNodeMatches = substitution.matchFrameNode(frameNode);
 
@@ -123,22 +123,19 @@ class Metavariable {
           metavariableString = this.string, ///
           substitutionString = (substitution !== null) ?
                                   substitution.getString() :
-                                    null;
+                                    EMPTY_STRING;
 
-    (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...`);
+    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
     const statementNode = statement.getNode(),
           metavariableNode = this.node, ///
-          metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
           substitutionNode = (substitution !== null) ?
                                 substitution.getSubstitutionNode() :
                                   null,
-          substitutionPresent = substitutions.isSubstitutionPresentByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode);
+          substitutionPresent = substitutions.isSubstitutionPresentByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
 
     if (substitutionPresent) {
-      const substitution = substitutions.findSubstitutionByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode),
+      const substitution = substitutions.findSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode),
             statementNodeMatches = substitution.matchStatementNode(statementNode);
 
       if (statementNodeMatches) {
@@ -149,7 +146,7 @@ class Metavariable {
             metavariable = metavariableFromMetavariableNode(metavariableNode, localContext),
             statementMetavariable = statementMetavariableFromStatementNode(statementNode, localContext);
 
-      if (metavariable === statementMetavariable) {
+      if ((metavariable !== null) && (metavariable === statementMetavariable)) {
         statementUnified = true;
       } else {
         const metavariable = this,  ///
@@ -164,9 +161,7 @@ class Metavariable {
     }
 
     if (statementUnified) {
-      (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.`);
+      localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable.`);
     }
 
     return statementUnified;
@@ -180,8 +175,8 @@ class Metavariable {
 
     localContext.trace(`Unifying the '${substitutionString}' substitution with the '${metavariableString}' metavariable...`);
 
-    const metavariableName = this.name, ///
-          judgement = localContext.findJudgementByMetavariableName(metavariableName);
+    const metavariableNode = this.node, ///
+          judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
 
     if (judgement !== null){
       const declaration = judgement.getDeclaration();
@@ -203,18 +198,10 @@ class Metavariable {
 
     localContext.trace(`Verifying the '${metavariableString}' metavariable...`);
 
-    const metavariableName = this.name,
-          metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
-
-    if (metavariable !== null) {
-      const metavariableA = metavariable, ///
-            metavariableB = this,
-            metavariableNodeA = metavariableA.getNode(), ///
-            metavariableNodeB = metavariableB.getNode(),
-            metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
+    const metavariableNode = this.node,
+          metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext);
 
-      verified = metavariableUnified; ///
-    }
+    verified = metavariablePresent; ///
 
     if (verified) {
       localContext.debug(`...verified the '${metavariableString}' metavariable.`);
@@ -223,12 +210,12 @@ class Metavariable {
     return verified;
   }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel = false;
 
     const metavariableString = this.string; ///
 
-    fileContext.trace(`Verifying the '${metavariableString}' metavariable at top level...`);
+    fileContext.trace(`Verifying the '${metavariableString}' metavariable when declared...`);
 
     const metavariableNode = this.node, ///
           metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
@@ -262,7 +249,7 @@ class Metavariable {
     }
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${metavariableString}' metavariable at top level.`);
+      fileContext.debug(`...verified the '${metavariableString}' metavariable when declared.`);
     }
 
     return verifiedAtTopLevel;
@@ -276,9 +263,8 @@ class Metavariable {
 
     localContext.trace(`Verifying the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type...`);
 
-    const name = this.getName(),
-          metavariableName = name,  ///
-          metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+    const metavariableNode = this.node,  ///
+          metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
 
     if (metavariable !== null) {
       const metaTypeMatches = metavariable.matchMetaType(metaType);
@@ -360,8 +346,7 @@ Object.assign(shim, {
 export default Metavariable;
 
 function metavariableFromMetavariableNode(metavariableNode, localContext) {
-  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
 
   return metavariable;
 }
@@ -372,9 +357,7 @@ function frameMetavariableFromStatementNode(frameNode, localContext) {
   const frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
 
   if (frameMetavariableNode !== null) {
-    const frameMetavariableName = metavariableNameFromMetavariableNode(frameMetavariableNode);
-
-    frameMetavariable = localContext.findMetavariableByMetavariableName(frameMetavariableName);
+    frameMetavariable = localContext.findMetavariableByMetavariableNode(frameMetavariableNode, localContext);
   }
 
   return frameMetavariable;
@@ -386,9 +369,7 @@ function statementMetavariableFromStatementNode(statementNode, localContext) {
   const statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
 
   if (statementMetavariableNode !== null) {
-    const statementMetavariableName = metavariableNameFromMetavariableNode(statementMetavariableNode);
-
-    statementMetavariable = localContext.findMetavariableByMetavariableName(statementMetavariableName);
+    statementMetavariable = localContext.findMetavariableByMetavariableNode(statementMetavariableNode, localContext);
   }
 
   return statementMetavariable;

package/src/mixins/statement/qualified/unify.js

@@ -135,8 +135,7 @@ function unifyAWithReference(qualifiedStatement, substitutions, localContext) {
 
   const reference = qualifiedStatement.getReference(),
         metavariableNode = reference.getMetavariableNode(),
-        metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariablePresent = localContext.isMetavariablePresentByMetavariableName(metavariableName);
+        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext);
 
   if (metavariablePresent) {
     const statement = qualifiedStatement.getStatement(),

package/src/mixins/statement/unify.js

@@ -28,10 +28,10 @@ function unifyWithCombinators(statement, assignments, stated, localContext) {
 
   const combinators = localContext.getCombinators();
 
-  assignments = null; ///
-
   stated = true;  ///
 
+  assignments = null; ///
+
   unifiedWithCombinators = combinators.some((combinator) => {
     const unifiedWithCombinator = unifyStatementWithCombinator(statement, combinator, assignments, stated, localContext);
 

package/src/mixins/statement/verify.js

@@ -1,10 +1,6 @@
 "use strict";
 
-import Frame from "../../frame";
-import Equality from "../../equality";
-import Judgement from "../../judgement";
-import Declaration from "../../declaration";
-import Metavariable from "../../metavariable";
+import shim from "../../shim";
 import TypeAssertion from "../../assertion/type";
 import DefinedAssertion from "../../assertion/defined";
 import SubproofAssertion from "../../assertion/subproof";
@@ -12,20 +8,19 @@ import ContainedAssertion from "../../assertion/contained";
 
 import { nodeQuery } from "../../utilities/query";
 
-const frameNodeQuery = nodeQuery("/statement/frame!"),
-      equalityNodeQuery = nodeQuery("/statement/equality!"),
-      judgementNodeQuery = nodeQuery("/statement/judgement!"),
-      declarationNodeQuery = nodeQuery("/statement/declaration!"),
+const equalityNodeQuery = nodeQuery("/statement/equality"),
+      judgementNodeQuery = nodeQuery("/statement/judgement"),
       metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
-      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
-      subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
-      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion"),
+      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion"),
+      subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion"),
+      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion");
 
 function verifyAsMetavariable(statement, assignments, stated, localContext) {
   let verifiedAsMetavariable = false;
 
-  const statementNode = statement.getNode(),
+  const { Metavariable } = shim,
+        statementNode = statement.getNode(),
         metavariableNode = metavariableNodeQuery(statementNode),
         metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext);
 
@@ -49,7 +44,8 @@ function verifyAsMetavariable(statement, assignments, stated, localContext) {
 function verifyAsEquality(statement, assignments, stated, localContext) {
   let verifiedAsEquality = false;
 
-  const statementNode = statement.getNode(),
+  const { Equality } = shim,
+        statementNode = statement.getNode(),
         equalityNode = equalityNodeQuery(statementNode),
         equality = Equality.fromEqualityNode(equalityNode, localContext);
 
@@ -70,34 +66,11 @@ function verifyAsEquality(statement, assignments, stated, localContext) {
   return verifiedAsEquality;
 }
 
-function verifyAsFrame(statement, assignments, stated, localContext) {
-  let verifiedAsFrame = false;
-
-  const statementNode = statement.getNode(),
-        frameNode = frameNodeQuery(statementNode),
-        frame = Frame.fromFrameNode(frameNode, localContext);
-
-  if (frame !== null) {
-    const statementString = statement.getString();
-
-    localContext.trace(`Verifying the '${statementString}' statement as a frame...`);
-
-    const frameVerified = frame.verify(assignments, stated, localContext);
-
-    verifiedAsFrame = frameVerified; ///
-
-    if (verifiedAsFrame) {
-      localContext.debug(`...verified the '${statementString}' statement as a frame.`);
-    }
-  }
-
-  return verifiedAsFrame;
-}
-
 function verifyAsJudgement(statement, assignments, stated, localContext) {
   let verifiedAsJudgement = false;
 
-  const statementNode = statement.getNode(),
+  const { Judgement } = shim,
+        statementNode = statement.getNode(),
         judgementNode = judgementNodeQuery(statementNode),
         judgement = Judgement.fromJudgementNode(judgementNode, localContext);
 
@@ -118,30 +91,6 @@ function verifyAsJudgement(statement, assignments, stated, localContext) {
   return verifiedAsJudgement;
 }
 
-function verifyAsDeclaration(statement, assignments, stated, localContext) {
-  let verifiedAsDeclaration = false;
-
-  const statementNode = statement.getNode(),
-        declarationNode = declarationNodeQuery(statementNode),
-        declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
-
-  if (declaration !== null) {
-    const statementString = statement.getString();
-
-    localContext.trace(`Verifying the '${statementString}' statement as a declaration...`);
-
-    const declarationVerified = declaration.verify(assignments, stated, localContext);
-
-    verifiedAsDeclaration = declarationVerified; ///
-
-    if (verifiedAsDeclaration) {
-      localContext.debug(`...verified the '${statementString}' statement as a declaration.`);
-    }
-  }
-
-  return verifiedAsDeclaration;
-}
-
 function verifyAsTypeAssertion(statement, assignments, stated, localContext) {
   let verifiedAsTypeAssertion = false;
 
@@ -190,60 +139,58 @@ function verifyAsDefinedAssertion(statement, assignments, stated, localContext)
   return verifiedAsDefinedAssertion;
 }
 
-function verifyAsSubproofAssertion(statement, assignments, stated, localContext) {
-  let verifiedAsSubproofAssertion = false;
+function verifyAsContainedAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsContainedAssertion = false;
 
   const statementNode = statement.getNode(),
-        subproofAssertionNode = subproofAssertionNodeQuery(statementNode),
-        subproofAssertion = SubproofAssertion.fromSubproofAssertionNode(subproofAssertionNode, localContext);
+        containedAssertionNode = containedAssertionNodeQuery(statementNode),
+        containedAssertion = ContainedAssertion.fromContainedAssertionNode(containedAssertionNode, localContext);
 
-  if (subproofAssertionNode !== null) {
+  if (containedAssertion !== null) {
     const statementString = statement.getString();
 
-    localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
+    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`);
 
-    const subproofAssertionVerified = subproofAssertion.verify(assignments, stated, localContext);
+    const containedAssertionVerified = containedAssertion.verify(assignments, stated, localContext);
 
-    verifiedAsSubproofAssertion = subproofAssertionVerified; ///
+    verifiedAsContainedAssertion = containedAssertionVerified; ///
 
-    if (verifiedAsSubproofAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a subproof assertion.`);
+    if (verifiedAsContainedAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`);
     }
   }
 
-  return verifiedAsSubproofAssertion;
+  return verifiedAsContainedAssertion;
 }
 
-function verifyAsContainedAssertion(statement, assignments, stated, localContext) {
-  let verifiedAsContainedAssertion = false;
+function verifyAsSubproofAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsSubproofAssertion = false;
 
   const statementNode = statement.getNode(),
-        containedAssertionNode = containedAssertionNodeQuery(statementNode),
-        containedAssertion = ContainedAssertion.fromContainedAssertionNode(containedAssertionNode, localContext);
+        subproofAssertionNode = subproofAssertionNodeQuery(statementNode),
+        subproofAssertion = SubproofAssertion.fromSubproofAssertionNode(subproofAssertionNode, localContext);
 
-  if (containedAssertion !== null) {
+  if (subproofAssertionNode !== null) {
     const statementString = statement.getString();
 
-    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`);
+    localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
 
-    const containedAssertionVerified = containedAssertion.verify(assignments, stated, localContext);
+    const subproofAssertionVerified = subproofAssertion.verify(assignments, stated, localContext);
 
-    verifiedAsContainedAssertion = containedAssertionVerified; ///
+    verifiedAsSubproofAssertion = subproofAssertionVerified; ///
 
-    if (verifiedAsContainedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`);
+    if (verifiedAsSubproofAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a subproof assertion.`);
     }
   }
 
-  return verifiedAsContainedAssertion;
+  return verifiedAsSubproofAssertion;
 }
 
 const verifyMixins = [
   verifyAsMetavariable,
   verifyAsEquality,
-  verifyAsFrame,
   verifyAsJudgement,
-  verifyAsDeclaration,
   verifyAsTypeAssertion,
   verifyAsDefinedAssertion,
   verifyAsSubproofAssertion,

package/src/mixins/term/verify.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Variable from "../../variable";
+import shim from "../../shim";
 
 import { nodeQuery } from "../../utilities/query";
 
@@ -9,7 +9,8 @@ const variableNodeQuery = nodeQuery("/term/variable!");
 function verifyTermAsVariable(term, localContext, verifyAhead) {
   let termVerifiedAsVariable = false;
 
-  const termNode = term.getNode(),
+  const { Variable } = shim,
+        termNode = term.getNode(),
         variableNode = variableNodeQuery(termNode),
         variable = Variable.fromVariableNode(variableNode, localContext);
 

package/src/premise.js

@@ -3,7 +3,6 @@
 import shim from "./shim";
 import LocalContext from "./context/local";
 import SubproofAssertion from "./assertion/subproof";
-import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
@@ -29,37 +28,6 @@ class Premise {
 
   getStatement() { return this.unqualifiedStatement.getStatement(); }
 
-  unifySubproof(subproof, substitutions, localContext) {
-    let subproofUnified = false;
-
-    const premise = this, ///
-          subproofString = subproof.getString(),
-          premiseStatement = premise.getStatement(),
-          premiseStatementString = premiseStatement.getString();
-
-    localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
-
-    const statement = this.unqualifiedStatement.getStatement(),
-          statementNode = statement.getNode(),
-          statementTokens = statement.getTokens(),
-          context = this.fileContext, ///
-          tokens = statementTokens; ///
-
-    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
-
-    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
-
-    if (subproofAssertion !== null) {
-      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
-    }
-
-    if (subproofUnified) {
-      localContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
-    }
-
-    return subproofUnified;
-  }
-
   unifyProofStep(proofStep, substitutions, localContext) {
     let proofStepUnified = false;
 
@@ -80,6 +48,14 @@ class Premise {
     }
 
     if (subproofUnified || statementUnified) {
+      const localContextB = localContext; ///
+
+      localContext = LocalContext.fromFileContext(this.fileContext);
+
+      const localContextA = localContext; ///
+
+      substitutions.resolve(localContextA, localContextB);
+
       proofStepUnified = true;
     }
 
@@ -113,6 +89,37 @@ class Premise {
     return statementUnified;
   }
 
+  unifySubproof(subproof, substitutions, localContext) {
+    let subproofUnified = false;
+
+    const premise = this, ///
+          subproofString = subproof.getString(),
+          premiseStatement = premise.getStatement(),
+          premiseStatementString = premiseStatement.getString();
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+
+    const statement = this.unqualifiedStatement.getStatement(),
+          statementNode = statement.getNode(),
+          statementTokens = statement.getTokens(),
+          context = this.fileContext, ///
+          tokens = statementTokens; ///
+
+    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
+
+    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
+
+    if (subproofAssertion !== null) {
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
+    }
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
+    }
+
+    return subproofUnified;
+  }
+
   verify(localContext) {
     let verified = false;
 
@@ -162,7 +169,8 @@ class Premise {
   }
 
   static fromPremiseNode(suppositionNode, fileContext) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
+    const { UnqualifiedStatement } = shim,
+          unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
           premise = new Premise(fileContext, unqualifiedStatement);
 

package/src/proof.js

@@ -1,13 +1,13 @@
 "use strict";
 
-import Derivation from "./derivation";
+import shim from "./shim";
 import LocalContext from "./context/local";
 
 import { nodeQuery } from "./utilities/query";
 
 const derivationNodeQuery = nodeQuery("/proof/derivation");
 
-export default class Proof {
+class Proof {
   constructor(derivation) {
     this.derivation = derivation;
   }
@@ -47,7 +47,8 @@ export default class Proof {
     let proof = null;
 
     if (proofNode !== null) {
-      const derivationNode = derivationNodeQuery(proofNode),
+      const { Derivation } = shim,
+            derivationNode = derivationNodeQuery(proofNode),
             derivation = Derivation.fromDerivationNode(derivationNode, fileContext);
 
       proof = new Proof(derivation);
@@ -56,3 +57,9 @@ export default class Proof {
     return proof;
   }
 }
+
+Object.assign(shim, {
+  Proof
+});
+
+export default Proof;