occam-verify-cli 0.0.1066 → 0.0.1068

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.`);
@@ -45,23 +57,41 @@ 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;
   }
 
+  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

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

package/src/subproof.js

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

package/src/substitution/frameForMetavariable.js

@@ -1,20 +1,26 @@
 "use strict";
 
+import shim from "../shim";
 import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
+import { metavariableNameFromMetavariableNode } from "../utilities/name";
+import { substitutionNodeFromSubstitutionTokens } from "../utilities/node";
+import { substitutionTokensFromSubstitutionString } from "../utilities/tokens";
 
-const substitutionNodeQuery = nodeQuery("/statement/substitution"),
-      substitutionFrameNodeQuery = nodeQuery("/substitution/frame!"),
-      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
-      substitutionMetavariableNodeQuery = nodeQuery("/substitution/metavariable!");
+const frameNodeQuery = nodeQuery("/substitution/frame[0]"),
+      metavariableNodeQuery = nodeQuery("/substitution/frame[1]/metavariable!"),
+      substitutionNodeQuery = nodeQuery("/statement/substitution"),
+      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable");
 
 export default class FrameForMetavariableSubstitution extends Substitution {
-  constructor(string, frameNode, metavariableNode) {
+  constructor(string, frameNode, metavariableNode, substitutionNode, substitutionTokens) {
     super(string);
 
     this.frameNode = frameNode;
     this.metavariableNode = metavariableNode;
+    this.substitutionNode = substitutionNode;
+    this.substitutionTokens = substitutionTokens;
   }
 
   getFrameNode() {
@@ -25,35 +31,45 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return this.metavariableNode;
   }
 
-  getNode() {
-    const node = this.frameNode;  ///
+  getSubstitutionNode() {
+    return this.substitutionNode;
+  }
 
-    return node;
+  getSubstitutionTokens() {
+    return this.substitutionTokens;
   }
 
-  transformed(substitutions) {
-    let transformedSubstitution = null;
+  getMetavariableName() {
+    const metavariableName = metavariableNameFromMetavariableNode(this.metavariableNode);
 
-    const transformedFrameNode = transformFrameNode(this.frameNode, substitutions),
-          transformedMetavariableNode = transformMetavariableNode(this.metavariableNode, substitutions);
+    return metavariableName;
+  }
 
-    if ((transformedFrameNode !== null) && (transformedMetavariableNode !== null)) {
-      const frameNode = transformedFrameNode, ///
-            metavariableNode = transformedMetavariableNode, ///
-            frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(frameNode, metavariableNode);
+  setSubstitutionNode() {
+    this.substitutionNode = substitutionNodeFromSubstitutionTokens(this.substitutionTokens);
+  }
 
-      transformedSubstitution = frameForMetavariableSubstitution;  ///
-    }
+  setSubstitutionTokens() {
+    const frameMetavariableNode = frameMetavariableNodeQuery(this.frameNode),
+        frameMetavariableName = metavariableNameFromMetavariableNode(frameMetavariableNode),
+        metavariableName = metavariableNameFromMetavariableNode(this.metavariableNode),
+        substitutionString = `[[${frameMetavariableName}] for [${metavariableName}]]`;
 
-    return transformedSubstitution;
+    this.substitutionTokens = substitutionTokensFromSubstitutionString(substitutionString);
   }
 
   isEqualTo(substitution) {
+    let equalTo = false;
+
     const frameNode = substitution.getFrameNode(),
-          metavariableNode = substitution.getMetavariableNode(),
-          frameNodeMatches = this.matchFrameNode(frameNode),
-          metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
-          equalTo = (frameNodeMatches && metavariableNodeMatches);
+          metavariableName = substitution.getMetavariableName();
+
+    if ((frameNode !== null) && (metavariableName !== null)) {
+      const frameNodeMatches = this.matchFrameNode(frameNode),
+            metavariableNameMatches = this.matchMetavariableName(metavariableName);
+
+      equalTo = (frameNodeMatches && metavariableNameMatches);
+    }
 
     return equalTo;
   }
@@ -64,28 +80,42 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return frameNodeMatches;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+  matchMetavariableName(metavariableName) {
+    let metavariableNameMatches;
 
-    return metavariableNodeMatches;
-  }
+    const metavariableNameA = metavariableName; ///
 
-  static fromSubstitution(substitution, localContextA, localContextB) {
-    let frameForMetavariableSubstitution = null;
+    metavariableName = metavariableNameFromMetavariableNode(this.metavariableNode);
 
-    const substitutionNode = substitution.getNode(),
-          substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
+    const metavariableNameB = metavariableName; ///
 
-    if (substitutionFrameNode !== null) {
-      const substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
-            metavariableNode = substitutionMetavariableNode,  ///
-            frameNode = substitutionFrameNode,  ///
-            string = stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB);
+    metavariableNameMatches = (metavariableNameA === metavariableNameB);
 
-        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode);
+    return metavariableNameMatches;
+  }
+
+  matchSubstitutionNode(substitutionNode) {
+    let substitutionNodeMatches;
+
+    if ((substitutionNode === null) && (this.substitutionNode === null)) {
+      substitutionNodeMatches = true;
+    } else if ((substitutionNode === null) && (this.substitutionNode !== null)) {
+      substitutionNodeMatches = false;
+    } else if ((substitutionNode !== null) && (this.substitutionNode === null)) {
+      substitutionNodeMatches = false;
+    } else {
+      substitutionNodeMatches = this.substitutionNode.match(substitutionNode);
     }
 
-    return frameForMetavariableSubstitution;
+    return substitutionNodeMatches;
+  }
+
+  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
+    const metavariableNameMatches = this.matchMetavariableName(metavariableName),
+          substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
+          metavariableNameAndSubstitutionNodeMatches = (metavariableNameMatches && substitutionNodeMatches);
+
+    return metavariableNameAndSubstitutionNodeMatches;
   }
 
   static fromStatementNode(statementNode, localContext) {
@@ -94,84 +124,40 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     const substitutionNode = substitutionNodeQuery(statementNode);
 
     if (substitutionNode !== null) {
-      const substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
+      const frameNode = frameNodeQuery(substitutionNode),
+            metavariableNode = metavariableNodeQuery(substitutionNode);
 
-      if (substitutionFrameNode !== null) {
-        const substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
-              metavariableNode = substitutionMetavariableNode,  ///
-              frameNode = substitutionFrameNode,  ///
-              localContextA = localContext, ///
-              localContextB = localContext, ///
-              string = stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB);
+      if ((frameNode !== null) && (metavariableNode !== null)) {
+        const { Frame, Metavariable } = shim,
+              frame = Frame.fromFrameNode(frameNode, localContext),
+              variable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+              string = stringFromFrameAndMetavariable(frame, variable, localContext),
+              substitutionTokens = localContext.nodeAsTokens(substitutionNode);
 
-        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode);
+        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode, substitutionTokens);
       }
-
     }
 
     return frameForMetavariableSubstitution;
   }
 
-  static fromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB) {
-    const string = stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB),
-          frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode);
+  static fromFrameAndMetavariable(frame, metavariable, localContext) {
+    const string = stringFromFrameAndMetavariable(frame, metavariable, localContext),
+          frameNode = frame.getNode(),
+          metavariableNode = metavariable.getNode(),
+          substitutionNode = null,
+          substitutionTokens = null,
+          statementForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode, substitutionTokens);
 
-    return frameForMetavariableSubstitution;
+    return statementForMetavariableSubstitution;
   }
 }
 
-function transformFrameNode(frameNode, substitutions) {
-  let transformedFrameNode = null;
-
-  const frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
-
-  if (frameMetavariableNode !== null) {
-    const metavariableNode = frameMetavariableNode;  ///
-
-    substitutions.someSubstitution((substitution) => {
-      const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
-
-      if (metavariableNodeMatches) {
-        const frameNode = substitution.getFrameNode();
-
-        transformedFrameNode = frameNode; ////
-
-        return true;
-      }
-    });
-  }
-
-  return transformedFrameNode;
-}
-
-function transformMetavariableNode(metavariableNode, substitutions) {
-  let transformedMetavariableNode = null;
-
-  substitutions.someSubstitution((substitution) => {
-    const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
-
-    if (metavariableNodeMatches) {
-      const frameNode = substitution.getFrameNode(),
-            frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
-
-      if (frameMetavariableNode !== null) {
-        transformedMetavariableNode = frameMetavariableNode;  ///
-
-        return true;
-      }
-    }
-  });
-
-  return transformedMetavariableNode;
-}
-
-function stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB) {
-  const frameNodeB = frameNode,  ///
-        frameStringB = localContextB.nodeAsString(frameNodeB),
-        metavariableNodeA = metavariableNode,  ///
-        metavariableStringA = localContextA.nodeAsString(metavariableNodeA),
-        string = `[${frameStringB} for ${metavariableStringA}]`;
+function stringFromFrameAndMetavariable(frame, metavariable, localContext) {
+  const frameNode = frame.getNode(),
+        frameString = localContext.nodeAsString(frameNode),
+        metavariableString = metavariable.getString(),
+        string = `[[${frameString}] for [${metavariableString}]]`;
 
   return string;
 }
-