occam-verify-cli 0.0.1065 → 0.0.1067

package/src/statement.js

@@ -9,17 +9,20 @@ import statementAsCombinatorVerifier from "./verifier/statementAsCombinator";
 
 import { nodeQuery, nodesQuery } from "./utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
-import { statementNodeFromStatementString } from "./utilities/node";
+import { statementTokensFromUnqualifiedStatementTokens, unqualifiedStatementTokensFromUnqualifiedStatementString } from "./utilities/tokens";
+import { statementNodeFromUnqualifiedStatementNode,
+         unqualifiedStatementStringFromStatementString,
+         unqualifiedStatementNodeFromUnqualifiedStatementTokens } from "./utilities/node";
 
 const statementNodeQuery = nodeQuery("/*//statement"),
-      substitutionNodeQuery = nodeQuery("/statement/substitution"),
       statementVariableNodesQuery = nodesQuery("/statement//variable"),
       statementMetavariableNodesQuery = nodesQuery("/statement//metavariable");
 
 class Statement {
-  constructor(string, node) {
+  constructor(string, node, tokens) {
     this.string = string;
     this.node = node;
+    this.tokens = tokens;
   }
 
   getString() {
@@ -30,6 +33,10 @@ class Statement {
     return this.node;
   }
 
+  getTokens() {
+    return this.tokens;
+  }
+
   isEqualTo(statement) {
     const node = statement.getNode(),
           matches = this.node.match(node),
@@ -44,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,
@@ -59,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;
@@ -71,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,
@@ -86,12 +93,44 @@ 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;
   }
 
+  matchStatementNode(statementNode) {
+    const statementNodeMatches = this.node.match(statementNode);
+
+    return statementNodeMatches;
+  }
+
+  unifyStatement(statement, substitutions, localContextA, localContextB) {
+    let statementUnified;
+
+    const statementA = this,  ///
+          statementB = statement, ///
+          statementAString = statementA.getString(),
+          statementBString = statementB.getString();
+
+    localContextB.trace(`Unifying the '${statementBString}' statement with the '${statementAString}' statement...`);
+
+    const statementANode = statementA.getNode(),
+          statementBNode = statementB.getNode(),
+          nodeA = statementANode, ///
+          nodeB = statementBNode; ///
+
+    localContextA = LocalContext.fromLocalContextAndTokens(localContextA, this.tokens);
+
+    const unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+    statementUnified = unifiedAtMetaLevel; ///
+
+    localContextB.debug(`...unified the '${statementBString}' statement with the '${statementAString}' statement.`);
+
+    return statementUnified;
+  }
+
   verify(assignments, stated, localContext) {
     let verified = false;
 
@@ -169,32 +208,6 @@ class Statement {
     return verifiedGivenMetaType;
   }
 
-  unifyStatement(statement, substitutions, fileContext, localContext) {
-    let statementUnified;
-
-    const statementA = this,  ///
-          statementB = statement, ///
-          statementAString = statementA.getString(),
-          statementBString = statementB.getString();
-
-    localContext.trace(`Unifying the '${statementBString}' statement with the '${statementAString}' statement...`);
-
-    const statementANode = statementA.getNode(),
-          statementBNode = statementB.getNode(),
-          nodeA = statementANode, ///
-          nodeB = statementBNode, ///
-          fileContextA = fileContext, ///
-          localContextA = LocalContext.fromFileContext(fileContextA),
-          localContextB = localContext, ///
-          unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-
-    statementUnified = unifiedAtMetaLevel; ///
-
-    localContext.debug(`...unified the '${statementBString}' statement with the '${statementAString}' statement.`);
-
-    return statementUnified;
-  }
-
   toJSON() {
     const string = this.string, ///
           json = {
@@ -209,9 +222,14 @@ class Statement {
           statementString = string, ///
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
-          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
+          unqualifiedStatementString = unqualifiedStatementStringFromStatementString(statementString),
+          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
+          statementTokens = statementTokensFromUnqualifiedStatementTokens(unqualifiedStatementTokens),
+          statementNode = statementNodeFromUnqualifiedStatementNode(unqualifiedStatementNode),
           node = statementNode,  ///
-          statement = new Statement(string, node);
+          tokens = statementTokens, ///
+          statement = new Statement(string, node, tokens);
 
     return statement;
   }
@@ -221,9 +239,10 @@ class Statement {
 
     if (statementNode !== null) {
       const node = statementNode, ///
-            string = localContext.nodeAsString(node);
+            tokens = localContext.nodeAsTokens(node),
+            string = localContext.tokensAsString(tokens);
 
-      statement = new Statement(string, node);
+      statement = new Statement(string, node, tokens);
     }
 
     return statement;
@@ -232,8 +251,9 @@ class Statement {
   static fromDefinedAssertionNode(definedAssertionNode, localContext) {
     const statementNode = statementNodeQuery(definedAssertionNode),
           node = statementNode, ///
-          string = localContext.nodeAsString(node),
-          statement = new Statement(string, node);
+          tokens = localContext.nodeAsTokens(node),
+          string = localContext.tokensAsString(tokens),
+          statement = new Statement(string, node, tokens);
 
     return statement;
   }
@@ -241,8 +261,9 @@ class Statement {
   static fromContainedAssertionNode(containedAssertionNode, localContext) {
     const statementNode = statementNodeQuery(containedAssertionNode),
           node = statementNode, ///
-          string = localContext.nodeAsString(node),
-          statement = new Statement(string, node);
+          tokens = localContext.nodeAsTokens(node),
+          string = localContext.tokensAsString(tokens),
+          statement = new Statement(string, node, tokens);
 
     return statement;
   }

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,19 +1,22 @@
 "use strict";
 
+import shim from "../shim";
 import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
 
-const substitutionFrameNodeQuery = nodeQuery("/substitution/frame!"),
+const substitutionNodeQuery = nodeQuery("/statement/substitution"),
+      substitutionFrameNodeQuery = nodeQuery("/substitution/frame!"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       substitutionMetavariableNodeQuery = nodeQuery("/substitution/metavariable!");
 
 export default class FrameForMetavariableSubstitution extends Substitution {
-  constructor(string, frameNode, metavariableNode) {
+  constructor(string, frameNode, metavariableNode, substitutionNode) {
     super(string);
 
     this.frameNode = frameNode;
     this.metavariableNode = metavariableNode;
+    this.substitutionNode = substitutionNode;
   }
 
   getFrameNode() {
@@ -24,10 +27,8 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return this.metavariableNode;
   }
 
-  getNode() {
-    const node = this.frameNode;  ///
-
-    return node;
+  getSubstitutionNode() {
+    return this.substitutionNode;
   }
 
   transformed(substitutions) {
@@ -37,9 +38,11 @@ export default class FrameForMetavariableSubstitution extends Substitution {
           transformedMetavariableNode = transformMetavariableNode(this.metavariableNode, substitutions);
 
     if ((transformedFrameNode !== null) && (transformedMetavariableNode !== null)) {
-      const frameNode = transformedFrameNode, ///
+      const string = null,  ///
+            frameNode = transformedFrameNode, ///
             metavariableNode = transformedMetavariableNode, ///
-            frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(frameNode, metavariableNode);
+            substitutionNode = null,
+            frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode);
 
       transformedSubstitution = frameForMetavariableSubstitution;  ///
     }
@@ -48,11 +51,17 @@ export default class FrameForMetavariableSubstitution extends Substitution {
   }
 
   isEqualTo(substitution) {
+    let equalTo = false;
+
     const frameNode = substitution.getFrameNode(),
-          metavariableNode = substitution.getMetavariableNode(),
-          frameNodeMatches = this.matchFrameNode(frameNode),
-          metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
-          equalTo = (frameNodeMatches && metavariableNodeMatches);
+          metavariableNode = substitution.getMetavariableNode();
+
+    if ((frameNode !== null) && (metavariableNode !== null)) {
+      const frameNodeMatches = this.matchFrameNode(frameNode),
+            metavariableNodeMatches = this.matchMetavariableNode(metavariableNode);
+
+      equalTo = (frameNodeMatches && metavariableNodeMatches);
+    }
 
     return equalTo;
   }
@@ -69,29 +78,52 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return metavariableNodeMatches;
   }
 
-  static fromSubstitution(substitution, localContextA, localContextB) {
+  matchSubstitutionNode(substitutionNode) {
+    const substitutionNodeMatches = this.substitutionNode.match(substitutionNode);
+
+    return substitutionNodeMatches;
+  }
+
+  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
+          substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
+          metavariableNodeAndSubstitutionNodeMatches = (metavariableNodeMatches && substitutionNodeMatches);
+
+    return metavariableNodeAndSubstitutionNodeMatches;
+  }
+
+  static fromStatementNode(statementNode, localContext) {
     let frameForMetavariableSubstitution = null;
 
-    const substitutionNode = substitution.getNode(),
-          substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
+    const substitutionNode = substitutionNodeQuery(statementNode);
+
+    if (substitutionNode !== null) {
+      let substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
 
-    if (substitutionFrameNode !== null) {
-      const substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
-            metavariableNode = substitutionMetavariableNode,  ///
-            frameNode = substitutionFrameNode,  ///
-            string = stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB);
+      if (substitutionFrameNode !== null) {
+        const { Frame, Metavariable } = shim,
+              substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
+              metavariableNode = substitutionMetavariableNode,  ///
+              frameNode = substitutionFrameNode,  ///
+              frame = Frame.fromTermNode(frameNode, localContext),
+              variable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+              string = stringFromFrameAndMetavariable(frame, variable, localContext);
 
-        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode);
+        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode);
+      }
     }
 
     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,
+          statementForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode);
 
-    return frameForMetavariableSubstitution;
+    return statementForMetavariableSubstitution;
   }
 }
 
@@ -140,13 +172,11 @@ function transformMetavariableNode(metavariableNode, substitutions) {
   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;
 }
-

package/src/substitution/statementForMetavariable.js

@@ -2,36 +2,41 @@
 
 import shim from "../shim";
 import Substitution from "../substitution";
-import TermForVariableSubstitution from "../substitution/termForVariable";
-import FrameForMetavariableSubstitution from "../substitution/frameForMetavariable";
+import Substitutions from "../substitutions";
 
 import { stripBracketsFromStatement } from "../utilities/brackets";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
-  constructor(string, statementNode, metavariableNode, substitution) {
+  constructor(string, statement, metavariable, substitution) {
     super(string);
 
-    this.statementNode = statementNode;
-    this.metavariableNode = metavariableNode;
+    this.statement = statement;
+    this.metavariable = metavariable;
     this.substitution = substitution;
   }
 
-  getStatementNode() {
-    return this.statementNode;
+  getStatement() {
+    return this.statement;
   }
 
-  getMetavariableNode() {
-    return this.metavariableNode;
+  getMetavariable() {
+    return this.metavariable;
   }
 
   getSubstitution() {
     return this.substitution;
   }
 
-  getNode() {
-    const node = this.statementNode;  ///
+  getStatementNode() {
+    const statementNode = this.statement.getNode();
+
+    return statementNode;
+  }
+
+  getMetavariableNode() {
+    const metavariableNode = this.metavariable.getNode();
 
-    return node;
+    return metavariableNode;
   }
 
   isSimple() {
@@ -40,89 +45,125 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return simple;
   }
 
-  matchStatementNode(statementNode) {
-    statementNode = stripBracketsFromStatement(statementNode); ///
+  resolve(substitutions, localContext) {
+    let resolved = false;
 
-    const statementNodeMatches = this.statementNode.match(statementNode);
+    const substitutionString = this.string;
 
-    return statementNodeMatches;
-  }
+    localContext.trace(`Resolving the ${substitutionString} substitution...`);
+
+    const metavariableNode = this.getMetavariableNode(),
+          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode);
+
+    if (simpleSubstitution !== null) {
+      const substitution = simpleSubstitution,  ///
+            substitutionResolved = substitution.resolveSubstitution(this.substitution, this.statement, substitutions, localContext);
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+      resolved = substitutionResolved; ///
+    }
+
+    if (resolved) {
+      localContext.debug(`...resolved the ${substitutionString} substitution.`);
+    }
 
-    return metavariableNodeMatches;
+    return resolved;
   }
 
-  static fromStatementAndMetavariable(statement, metavariable, localContext) {
-    let statementNode = statement.getNode();
+  resolveSubstitution(substitution, statement, substitutions, localContext) {
+    let substitutionResolved = false;
 
-    statementNode = stripBracketsFromStatement(statementNode); ///
+    const substitutionString = substitution.getString();
 
-    const { Statement } = shim;
+    localContext.trace(`Resolving the ${substitutionString} substitution...`);
 
-    statement = Statement.fromStatementNode(statementNode, localContext); ///
+    const transformedSubstitution = substitution.transformed(substitutions, localContext);
 
-    const string = stringFromStatementAndMetavariable(statement, metavariable),
-          substitution = null,
-          metavariableNode = metavariable.getNode(),
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statementNode, metavariableNode, substitution);
+    if (transformedSubstitution !== null) {
+      const transformedSubstitutionString = transformedSubstitution.getString();
 
-    return statementForMetavariableSubstitution;
-  }
+      localContext.trace(`Transformed the substitution to ${transformedSubstitutionString}...`);
 
-  static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
-    let statementNode = statement.getNode();
+      substitutions = Substitutions.fromNothing();  ///
 
-    statementNode = stripBracketsFromStatement(statementNode); ///
+      const localContextA = localContext, ///
+            localContextB = localContext, ///
+            statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
-    const { Statement } = shim;
+      if (statementUnified) {
+        const substitutionsLength = substitutions.getLength();
 
-    statement = Statement.fromStatementNode(statementNode, localContext); ///
+        if (substitutionsLength === 1) {
+          const firstSubstitution = substitutions.getFirstSubstitution(),
+                substitution = firstSubstitution, ///
+                substitutionEqualToTransformedSubstitution = substitution.isEqualTo(transformedSubstitution);
 
-    const metavariableNode = metavariable.getNode(),
-          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution);
+          substitutionResolved = substitutionEqualToTransformedSubstitution;  ///
+        }
+      }
+    }
 
-    substitution = substitutionFromSubstitution(substitution, localContext);
+    if (substitutionResolved) {
+      localContext.debug(`...resolved the ${substitutionString} substitution.`);
+    }
 
-    const statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statementNode, metavariableNode, substitution);
+    return substitutionResolved;
+  }
 
-    return statementForMetavariableSubstitution;
+  matchStatementNode(statementNode) {
+    statementNode = stripBracketsFromStatement(statementNode); ///
+
+    const statementNodeMatches = this.statement.matchStatementNode(statementNode);
+
+    return statementNodeMatches;
   }
-}
 
-function substitutionFromSubstitution(substitution, localContext) {
-  if (substitution === null) {
-    const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitution(substitution, localContext);
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
+
+  matchSubstitutionNode(substitutionNode) {
+    let substitutionNodeMatches;
 
-    if (termForVariableSubstitution !== null) {
-      substitution = termForVariableSubstitution; ///
+    if ((substitutionNode === null) && (this.substitution === null)) {
+      substitutionNodeMatches = true;
+    } else if ((substitutionNode === null) && (this.substitution !== null)) {
+      substitutionNodeMatches = false;
+    } else if ((substitutionNode !== null) && (this.substitution === null)) {
+      substitutionNodeMatches = false;
+    } else {
+      substitutionNodeMatches = this.substitution.matchSubstitutionNode(substitutionNode);
     }
+
+    return substitutionNodeMatches;
   }
 
-  if (substitution === null) {
-    const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitution(substitution, localContext);
+  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
+          substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
+          metavariableNodeAndSubstitutionNodeMatches = (metavariableNodeMatches && substitutionNodeMatches);
 
-    if (frameForMetavariableSubstitution !== null) {
-      substitution = frameForMetavariableSubstitution;  ///
-    }
+    return metavariableNodeAndSubstitutionNodeMatches;
   }
 
-  return substitution;
-}
+  static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
+    let statementNode = statement.getNode();
 
-function stringFromStatementAndMetavariable(statement, metavariable) {
-  const statementString = statement.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${statementString} for ${metavariableString}]`;
+    statementNode = stripBracketsFromStatement(statementNode); ///
 
-  return string;
+    const { Statement } = shim;
+
+    statement = Statement.fromStatementNode(statementNode, localContext);
+
+    const string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statement, metavariable, substitution);
+
+    return statementForMetavariableSubstitution;
+  }
 }
 
-function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution) {
+function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
   let string;
 
-  const statementString = statement.getString(),
+  const statementNode = statement.getNode(),
+        statementString = localContext.nodeAsString(statementNode),
         metavariableString = metavariable.getString();
 
   if (substitution === null) {