occam-verify-cli 0.0.1067 → 0.0.1068

package/src/metavariable.js

@@ -4,6 +4,7 @@ import shim from "./shim";
 import Argument from "./argument";
 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";
@@ -13,6 +14,7 @@ import { metavariableNodeFromMetavariableString } from "./utilities/node";
 const argumentNodeQuery = nodeQuery("/metavariable/argument"),
       metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType"),
       metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
+      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 class Metavariable {
@@ -50,6 +52,12 @@ class Metavariable {
     return metaTypeName;
   }
 
+  matchMetaType(metaType) {
+    const metaTypeMatches = (this.metaType === metaType);
+
+    return metaTypeMatches;
+  }
+
   matchMetavariableName(metavariableName) {
     const metavariableNameMatches = (this.name === metavariableName);
 
@@ -62,6 +70,107 @@ class Metavariable {
     return metavariableNodeMatches;
   }
 
+  unifyFrame(frame, substitutions, localContext) {
+    let frameUnified = false;
+
+    const frameNode = frame.getNode(),
+          frameString = frame.getString(),
+          metavariableString = this.string; ///
+
+    localContext.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
+
+    const metavariableName = this.name, ///
+          simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariableName(metavariableName);
+
+    if (simpleSubstitutionPresent) {
+      const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableName(metavariableName),
+            substitution = simpleSubstitution,  ///
+            frameNodeMatches = substitution.matchFrameNode(frameNode);
+
+      if (frameNodeMatches) {
+        frameUnified = true;
+      }
+    } else {
+      const metavariableNode = this.node,  ///
+            metavariable = metavariableFromMetavariableNode(metavariableNode, localContext),
+            frameMetavariable  = frameMetavariableFromStatementNode(frameNode, localContext);
+
+      if (metavariable === frameMetavariable) {
+        frameUnified = true;
+      } else {
+        const metavariable = this,  ///
+              frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromFrameAndMetavariable(frame, metavariable, localContext),
+              substitution = frameForMetavariableSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, localContext);
+
+        frameUnified = true;
+      }
+    }
+
+    if (frameUnified) {
+      localContext.debug(`...unified the '${frameString}' frame with the '${metavariableString}' metavariable.`);
+    }
+
+    return frameUnified;
+  }
+
+  unifyStatement(statement, substitution, substitutions, localContext) {
+    let statementUnified = false;
+
+    const statementString = statement.getString(),
+          metavariableString = this.string, ///
+          substitutionString = (substitution !== null) ?
+                                  substitution.getString() :
+                                    null;
+
+    (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, ///
+          metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+          substitutionNode = (substitution !== null) ?
+                                substitution.getSubstitutionNode() :
+                                  null,
+          substitutionPresent = substitutions.isSubstitutionPresentByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode);
+
+    if (substitutionPresent) {
+      const substitution = substitutions.findSubstitutionByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode),
+            statementNodeMatches = substitution.matchStatementNode(statementNode);
+
+      if (statementNodeMatches) {
+        statementUnified = true;
+      }
+    } else {
+      const metavariableNode = this.node,  ///
+            metavariable = metavariableFromMetavariableNode(metavariableNode, localContext),
+            statementMetavariable = statementMetavariableFromStatementNode(statementNode, localContext);
+
+      if (metavariable === statementMetavariable) {
+        statementUnified = true;
+      } else {
+        const metavariable = this,  ///
+              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
+
+        substitution = statementForMetavariableSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, localContext);
+
+        statementUnified = true;
+      }
+    }
+
+    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.`);
+    }
+
+    return statementUnified;
+  }
+
   verify(localContext) {
     let verified;
 
@@ -80,7 +189,6 @@ class Metavariable {
             metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
 
       verified = metavariableUnified; ///
-
     }
 
     if (verified) {
@@ -125,55 +233,29 @@ class Metavariable {
     return verifiedAtTopLevel;
   }
 
-  unifyStatement(statement, substitution, substitutions, localContext) {
-    let statementUnified = false;
-
-    const statementString = statement.getString(),
-          metavariableString = this.string, ///
-          substitutionString = (substitution !== null) ?
-                                  substitution.getString() :
-                                    null;
-
-    (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, ///
-          substitutionNode = (substitution !== null) ?
-                               substitution.getSubstitutionNode() :
-                                 null,
-          substitutionPresent = substitutions.isSubstitutionPresentByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
-
-    if (substitutionPresent) {
-      const substitution = substitutions.findSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode),
-            statementNodeMatches = substitution.matchStatementNode(statementNode);
+  verifyGivenMetaType(metaType, localContext) {
+    let verifiedGivenMetaType = false;
 
-      if (statementNodeMatches) {
-        statementUnified = true;
-      }
-    } else {
-      const metavariable = this, ///
-            statementMetavariable = statementMetavariableFromStatementNode(statementNode, localContext);
+    const metavariableString = this.string,  ///
+          metaTypeString = metaType.getString();
 
-      if (metavariable === statementMetavariable) {
-        statementUnified = true;
-      } else {
-        const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
+    localContext.trace(`Verifying the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type...`);
 
-        substitution = statementForMetavariableSubstitution;  ///
+    const name = this.getName(),
+          metavariableName = name,  ///
+          metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
 
-        substitutions.addSubstitution(substitution, localContext);
+    if (metavariable !== null) {
+      const metaTypeMatches = metavariable.matchMetaType(metaType);
 
-        statementUnified = true;
-      }
+      verifiedGivenMetaType = metaTypeMatches;  ///
     }
 
-    (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.`);
+    if (verifiedGivenMetaType) {
+      localContext.debug(`...verified the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type.`);
+    }
 
-    return statementUnified;
+    return verifiedGivenMetaType;
   }
 
   toJSON() {
@@ -257,6 +339,27 @@ function metaTypeFromJSON(json, fileContext) {
   return metaType;
 }
 
+function metavariableFromMetavariableNode(metavariableNode, localContext) {
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+
+  return metavariable;
+}
+
+function frameMetavariableFromStatementNode(frameNode, localContext) {
+  let frameMetavariable = null;
+
+  const frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
+
+  if (frameMetavariableNode !== null) {
+    const frameMetavariableName = metavariableNameFromMetavariableNode(frameMetavariableNode);
+
+    frameMetavariable = localContext.findMetavariableByMetavariableName(frameMetavariableName);
+  }
+
+  return frameMetavariable;
+}
+
 function statementMetavariableFromStatementNode(statementNode, localContext) {
   let statementMetavariable = null;
 

package/src/mixins/statement/unify.js

@@ -1,12 +1,8 @@
 "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;
 
@@ -47,28 +43,10 @@ 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,
-  unifyWithProofSteps
+  unifyWithCombinators
 ];
 
 export default unifyMixins;

package/src/mixins/statement/verify.js

@@ -1,16 +1,15 @@
 "use strict";
 
+import Frame from "../../frame";
 import Equality from "../../equality";
+import Judgement from "../../judgement";
+import Declaration from "../../declaration";
 import Metavariable from "../../metavariable";
 import TypeAssertion from "../../assertion/type";
 import DefinedAssertion from "../../assertion/defined";
 import SubproofAssertion from "../../assertion/subproof";
 import ContainedAssertion from "../../assertion/contained";
 
-import verifyFrame from "../../verify/frame";
-import verifyJudgement from "../../verify/judgement";
-import verifyDeclaration from "../../verify/declaration";
-
 import { nodeQuery } from "../../utilities/query";
 
 const frameNodeQuery = nodeQuery("/statement/frame!"),
@@ -75,14 +74,15 @@ function verifyAsFrame(statement, assignments, stated, localContext) {
   let verifiedAsFrame = false;
 
   const statementNode = statement.getNode(),
-        frameNode = frameNodeQuery(statementNode);
+        frameNode = frameNodeQuery(statementNode),
+        frame = Frame.fromFrameNode(frameNode, localContext);
 
-  if (frameNode !== null) {
+  if (frame !== null) {
     const statementString = statement.getString();
 
     localContext.trace(`Verifying the '${statementString}' statement as a frame...`);
 
-    const frameVerified = verifyFrame(frameNode, assignments, stated, localContext);
+    const frameVerified = frame.verify(assignments, stated, localContext);
 
     verifiedAsFrame = frameVerified; ///
 
@@ -98,14 +98,15 @@ function verifyAsJudgement(statement, assignments, stated, localContext) {
   let verifiedAsJudgement = false;
 
   const statementNode = statement.getNode(),
-        judgementNode = judgementNodeQuery(statementNode);
+        judgementNode = judgementNodeQuery(statementNode),
+        judgement = Judgement.fromJudgementNode(judgementNode, localContext);
 
-  if (judgementNode !== null) {
+  if (judgement !== null) {
     const statementString = statement.getString();
 
     localContext.trace(`Verifying the '${statementString}' statement as a judgement...`);
 
-    const judgementVerified = verifyJudgement(judgementNode, assignments, stated, localContext);
+    const judgementVerified = judgement.verify(assignments, stated, localContext);
 
     verifiedAsJudgement = judgementVerified;  ///
 
@@ -121,14 +122,15 @@ function verifyAsDeclaration(statement, assignments, stated, localContext) {
   let verifiedAsDeclaration = false;
 
   const statementNode = statement.getNode(),
-        declarationNode = declarationNodeQuery(statementNode);
+        declarationNode = declarationNodeQuery(statementNode),
+        declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
 
-  if (declarationNode !== null) {
+  if (declaration !== null) {
     const statementString = statement.getString();
 
     localContext.trace(`Verifying the '${statementString}' statement as a declaration...`);
 
-    const declarationVerified = verifyDeclaration(declarationNode, assignments, stated, localContext);
+    const declarationVerified = declaration.verify(assignments, stated, localContext);
 
     verifiedAsDeclaration = declarationVerified; ///
 

package/src/premise.js

@@ -61,12 +61,19 @@ export default class Premise {
 
     substitutions.snapshot();
 
+    let subproofUnified = false,
+        statementUnified = false;
+
     if (false) {
       ///
     } else if (subproof !== null) {
-      proofStepUnified = this.unifySubproof(subproof, substitutions, localContext);
+      subproofUnified = this.unifySubproof(subproof, substitutions, localContext);
     } else if (statement !== null) {
-      proofStepUnified = this.unifyStatement(statement, substitutions, localContext);
+      statementUnified = this.unifyStatement(statement, substitutions, localContext);
+    }
+
+    if (subproofUnified || statementUnified) {
+      proofStepUnified = true;
     }
 
     proofStepUnified ?
@@ -82,18 +89,18 @@ export default class Premise {
     const statementString = statement.getString(),
           premiseString = this.getString();
 
-    localContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
-
-    const localContextB = localContext;
+    const localContextB = localContext; ///
 
     localContext = LocalContext.fromFileContext(this.fileContext);
 
     const localContextA = localContext; ///
 
+    localContextB.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
+
     statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
+      localContextB.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
     }
 
     return statementUnified;

package/src/reference.js

@@ -3,6 +3,7 @@
 import Metavariable from "./metavariable";
 
 import { nodeQuery } from "./utilities/query";
+import { referenceMetaType } from "./metaType";
 
 const metavariableNodeQuery = nodeQuery("//reference/metavariable");
 
@@ -25,20 +26,23 @@ export default class Reference {
     return metavariableNode;
   }
 
-  verifyAtTopLevel(fileContext) {
-    let verifiedAtTopLevel;
+  verify(localContext) {
+    let verified;
 
     const referenceString = this.getString(); ///
 
-    fileContext.trace(`Verifying the '${referenceString}' reference at top level...`);
+    localContext.trace(`Verifying the '${referenceString}' reference...`);
 
-    verifiedAtTopLevel = true;
+    const metaType = referenceMetaType, ///
+          metavariableVerifiedGivenMetaType = this.metavariable.verifyGivenMetaType(metaType, localContext);
 
-    if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${referenceString}' reference at top level.`);
+    verified = metavariableVerifiedGivenMetaType; ///
+
+    if (verified) {
+      localContext.debug(`...verified the '${referenceString}' reference.`);
     }
 
-    return verifiedAtTopLevel;
+    return verified;
   }
 
   toJSON() {

package/src/rule.js

@@ -70,7 +70,13 @@ export default class Rule {
       const statementUnifiedWithConclusion = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
 
       if (statementUnifiedWithConclusion) {
-        const substitutionsResolved = substitutions.resolve(localContext);
+        const localContextB = localContext; ///
+
+        localContext = LocalContext.fromFileContext(this.fileContext);
+
+        const localContextA = localContext; ///
+
+        const substitutionsResolved = substitutions.resolve(localContextA, localContextB);
 
         statementUnified = substitutionsResolved; ///
       }

package/src/ruleNames.js

@@ -2,5 +2,6 @@
 
 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/unqualified.js

@@ -1,11 +1,15 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import shim from "../shim";
 import LocalContext from "../context/local";
 
 import { trim } from "../utilities/string";
 import { nodeQuery } from "../utilities/query";
 
+const { reverse } = arrayUtilities;
+
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement");
 
 export default class UnqualifiedStatement {
@@ -32,7 +36,15 @@ export default class UnqualifiedStatement {
 
       const statementVerified = this.statement.verify(assignments, stated, localContext);
 
-      verified = statementVerified; ///
+      if (statementVerified) {
+        verified = true;
+      } else {
+        const statementUnifiedWithProofSteps = this.unifyStatementWithProofSteps(this.statement, assignments, stated, localContext);
+
+        if (statementUnifiedWithProofSteps) {
+          verified = true;
+        }
+      }
 
       if (verified) {
         localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`);
@@ -62,6 +74,24 @@ export default class UnqualifiedStatement {
     return statementUnified;
   }
 
+  unifyStatementWithProofSteps(statement, assignments, stated, localContext) {
+    let statementUnifiedWithProofSteps;
+
+    let proofSteps = localContext.getProofSteps();
+
+    proofSteps = reverse(proofSteps); ///
+
+    statementUnifiedWithProofSteps = proofSteps.some((proofStep) => {
+      const statementUnified = proofStep.unifyStatement(statement, localContext);
+
+      if (statementUnified) {
+        return true;
+      }
+    });
+
+    return statementUnifiedWithProofSteps;
+  }
+
   toJSON() {
     const statementJSON = this.statement.toJSON(),
           statement = statementJSON,  ///

package/src/statement.js

@@ -126,7 +126,9 @@ class Statement {
 
     statementUnified = unifiedAtMetaLevel; ///
 
-    localContextB.debug(`...unified the '${statementBString}' statement with the '${statementAString}' statement.`);
+    if (statementUnified) {
+      localContextB.debug(`...unified the '${statementBString}' statement with the '${statementAString}' statement.`);
+    }
 
     return statementUnified;
   }