occam-verify-cli 0.0.1066 → 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,10 +52,16 @@ class Metavariable {
     return metaTypeName;
   }
 
-  matchName(name) {
-    const nameMatches = (this.name === name);
+  matchMetaType(metaType) {
+    const metaTypeMatches = (this.metaType === metaType);
 
-    return nameMatches;
+    return metaTypeMatches;
+  }
+
+  matchMetavariableName(metavariableName) {
+    const metavariableNameMatches = (this.name === metavariableName);
+
+    return metavariableNameMatches;
   }
 
   matchMetavariableNode(metavariableNode) {
@@ -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,90 +233,29 @@ class Metavariable {
     return verifiedAtTopLevel;
   }
 
-  unifyStatement(statement, substitutions, localContext) {
-    let statementUnified = false;
-
-    const statementString = statement.getString(),
-          metavariableString = this.string; ///
-
-    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable...`);
-
-    const statementNode = statement.getNode(),
-          metavariableNode = this.node, ///
-          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode),
-          substitution = simpleSubstitution;  ///
-
-    if (substitution !== null) {
-      const statementNodeMatches = substitution.matchStatementNode(statementNode);
-
-      if (statementNodeMatches) {
-        statementUnified = true;
-      }
-    } else {
-      const metavariable = this, ///
-            statementMetavariable = statementMetavariableFromStatementNode(statementNode, localContext);
-
-      if (metavariable === statementMetavariable) {
-        statementUnified = true;
-      } else {
-        const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, localContext),
-              substitution = statementForMetavariableSubstitution;  ///
+  verifyGivenMetaType(metaType, localContext) {
+    let verifiedGivenMetaType = false;
 
-        substitutions.addSubstitution(substitution, localContext);
+    const metavariableString = this.string,  ///
+          metaTypeString = metaType.getString();
 
-        statementUnified = true;
-      }
-    }
+    localContext.trace(`Verifying the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type...`);
 
-    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);
-
-        substitution = statementForMetavariableSubstitution;  ///
+    const name = this.getName(),
+          metavariableName = name,  ///
+          metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
 
-        substitutions.addSubstitution(substitution, localContext);
+    if (metavariable !== null) {
+      const metaTypeMatches = metavariable.matchMetaType(metaType);
 
-        statementUnifiedGivenSubstitution = true;
-      }
+      verifiedGivenMetaType = metaTypeMatches;  ///
     }
 
-    if (statementUnifiedGivenSubstitution) {
-      localContext.trace(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable given the '${substitutionString}' substitution.`);
+    if (verifiedGivenMetaType) {
+      localContext.debug(`...verified the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type.`);
     }
 
-    return statementUnifiedGivenSubstitution;
+    return verifiedGivenMetaType;
   }
 
   toJSON() {
@@ -292,19 +339,25 @@ function metaTypeFromJSON(json, fileContext) {
   return metaType;
 }
 
-function metavariableFromStatementNode(statementNode, localContext) {
-  let metavariable = null;
+function metavariableFromMetavariableNode(metavariableNode, localContext) {
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
 
-  const statementMetavariableNode = statementMetavariableNodeQuery(statementNode)
+  return metavariable;
+}
 
-  if (statementMetavariableNode !== null) {
-    const metavariableNode = statementMetavariableNode, ///
-          metavariableName = metavariableNameFromMetavariableNode(metavariableNode);
+function frameMetavariableFromStatementNode(frameNode, localContext) {
+  let frameMetavariable = null;
 
-    metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+  const frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
+
+  if (frameMetavariableNode !== null) {
+    const frameMetavariableName = metavariableNameFromMetavariableNode(frameMetavariableNode);
+
+    frameMetavariable = localContext.findMetavariableByMetavariableName(frameMetavariableName);
   }
 
-  return metavariable;
+  return frameMetavariable;
 }
 
 function statementMetavariableFromStatementNode(statementNode, localContext) {

package/src/mixins/statement/unify.js

@@ -43,6 +43,7 @@ function unifyWithCombinators(statement, assignments, stated, localContext) {
   return unifiedWithCombinators;
 }
 
+
 const unifyMixins = [
   unifyWithBracketedCombinator,
   unifyWithCombinators

package/src/mixins/statement/verify.js

@@ -1,17 +1,14 @@
 "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 TermForVariableSubstitution from "../../substitution/termForVariable";
-import FrameForMetavariableSubstitution from "../../substitution/frameForMetavariable";
-
-import verifyFrame from "../../verify/frame";
-import verifyJudgement from "../../verify/judgement";
-import verifyDeclaration from "../../verify/declaration";
 
 import { nodeQuery } from "../../utilities/query";
 
@@ -39,19 +36,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.`);
@@ -89,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; ///
 
@@ -112,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;  ///
 
@@ -135,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

@@ -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";
 
@@ -60,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 ?
@@ -81,12 +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; ///
+
+    localContext = LocalContext.fromFileContext(this.fileContext);
+
+    const localContextA = localContext; ///
+
+    localContextB.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
 
-    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, this.fileContext, localContext);
+    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/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/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

@@ -67,7 +67,19 @@ 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 localContextB = localContext; ///
+
+        localContext = LocalContext.fromFileContext(this.fileContext);
+
+        const localContextA = localContext; ///
+
+        const substitutionsResolved = substitutions.resolve(localContextA, localContextB);
+
+        statementUnified = substitutionsResolved; ///
+      }
     }
 
     return statementUnified;

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/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;