occam-verify-cli 0.0.1066 → 0.0.1067

package/src/substitution/frameForMetavariable.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import shim from "../shim";
 import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
@@ -10,11 +11,12 @@ const substitutionNodeQuery = nodeQuery("/statement/substitution"),
       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() {
@@ -25,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) {
@@ -38,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;  ///
     }
@@ -49,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;
   }
@@ -70,22 +78,18 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return metavariableNodeMatches;
   }
 
-  static fromSubstitution(substitution, localContextA, localContextB) {
-    let frameForMetavariableSubstitution = null;
-
-    const substitutionNode = substitution.getNode(),
-          substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
+  matchSubstitutionNode(substitutionNode) {
+    const substitutionNodeMatches = this.substitutionNode.match(substitutionNode);
 
-    if (substitutionFrameNode !== null) {
-      const substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
-            metavariableNode = substitutionMetavariableNode,  ///
-            frameNode = substitutionFrameNode,  ///
-            string = stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB);
+    return substitutionNodeMatches;
+  }
 
-        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode);
-    }
+  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
+          substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
+          metavariableNodeAndSubstitutionNodeMatches = (metavariableNodeMatches && substitutionNodeMatches);
 
-    return frameForMetavariableSubstitution;
+    return metavariableNodeAndSubstitutionNodeMatches;
   }
 
   static fromStatementNode(statementNode, localContext) {
@@ -94,29 +98,32 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     const substitutionNode = substitutionNodeQuery(statementNode);
 
     if (substitutionNode !== null) {
-      const substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
+      let substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
 
       if (substitutionFrameNode !== null) {
-        const substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
+        const { Frame, Metavariable } = shim,
+              substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
               metavariableNode = substitutionMetavariableNode,  ///
               frameNode = substitutionFrameNode,  ///
-              localContextA = localContext, ///
-              localContextB = localContext, ///
-              string = stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB);
+              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;
   }
 }
 
@@ -165,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) {

package/src/substitution/termForVariable.js

@@ -12,11 +12,12 @@ const substitutionNodeQuery = nodeQuery("/statement/substitution"),
       substitutionsVariableNodeQuery = nodeQuery("/substitution/variable!");
 
 export default class TermForVariableSubstitution extends Substitution {
-  constructor(string, termNode, variableNode) {
+  constructor(string, termNode, variableNode, substitutionNode) {
     super(string);
 
     this.termNode = termNode;
     this.variableNode = variableNode;
+    this.substitutionNode = substitutionNode;
   }
 
   getTermNode() {
@@ -27,7 +28,11 @@ export default class TermForVariableSubstitution extends Substitution {
     return this.variableNode;
   }
 
-  transformed(substitutions) {
+  getSubstitutionNode() {
+    return this.substitutionNode;
+  }
+
+  transformed(substitutions, localContext) {
     let transformedSubstitution = null;
 
     const transformedTermNode = transformTermNode(this.termNode, substitutions),
@@ -36,7 +41,11 @@ export default class TermForVariableSubstitution extends Substitution {
     if ((transformedTermNode !== null) && (transformedVariableNode !== null)) {
       const termNode = transformedTermNode, ///
             variableNode = transformedVariableNode, ///
-            termForVariableSubstitution = new TermForVariableSubstitution(termNode, variableNode);
+            termString = localContext.nodeAsString(termNode),
+            variableString = localContext.nodeAsString(variableNode),
+            string = `[${termString} for ${variableString}]`,
+            substitutionNode = null,
+            termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode);
 
       transformedSubstitution = termForVariableSubstitution;  ///
     }
@@ -45,11 +54,17 @@ export default class TermForVariableSubstitution extends Substitution {
   }
 
   isEqualTo(substitution) {
+    let equalTo = false;
+
     const termNode = substitution.getTermNode(),
-          variableNode = substitution.getVariableNode(),
-          termNodeMatches = this.matchTermNode(termNode),
-          variableNodeMatches = this.matchVariableNode(variableNode),
-          equalTo = (termNodeMatches && variableNodeMatches);
+          variableNode = substitution.getVariableNode();
+
+    if ((termNode !== null) && (variableNode !== null)) {
+      const termNodeMatches = this.matchTermNode(termNode),
+            variableNodeMatches = this.matchVariableNode(variableNode);
+
+      equalTo = (termNodeMatches && variableNodeMatches);
+    }
 
     return equalTo;
   }
@@ -68,6 +83,12 @@ export default class TermForVariableSubstitution extends Substitution {
     return variableNodeMatches;
   }
 
+  matchSubstitutionNode(substitutionNode) {
+    const substitutionNodeMatches = this.substitutionNode.match(substitutionNode);
+
+    return substitutionNodeMatches;
+  }
+
   unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
     let unifiedWithEquivalence;
 
@@ -84,34 +105,6 @@ export default class TermForVariableSubstitution extends Substitution {
     return unifiedWithEquivalence;
   }
 
-  static fromSubstitution(substitution, localContext) {
-    let termForVariableSubstitution = null;
-
-    const substitutionNode = substitution.getNode();
-
-    let substitutionTermNode = substitutionTermNodeQuery(substitutionNode);
-
-    if (substitutionTermNode !== null) {
-      let termNode;
-
-      const substitutionVariableNode = substitutionsVariableNodeQuery(substitutionNode),
-            variableNode = substitutionVariableNode;  ///
-
-      termNode = substitutionTermNode;  ///
-
-      termNode = stripBracketsFromTerm(termNode); ///
-
-      const { Term, Variable } = shim,
-            term = Term.fromTermNode(termNode, localContext),
-            variable = Variable.fromVariableNode(variableNode, localContext),
-            string = stringFromTermAndVariable(term, variable);
-
-      termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
-    }
-
-    return termForVariableSubstitution;
-  }
-
   static fromStatementNode(statementNode, localContext) {
     let termForVariableSubstitution = null;
 
@@ -121,33 +114,30 @@ export default class TermForVariableSubstitution extends Substitution {
       let substitutionTermNode = substitutionTermNodeQuery(substitutionNode);
 
       if (substitutionTermNode !== null) {
-        let termNode;
-
-        const substitutionVariableNode = substitutionsVariableNodeQuery(substitutionNode),
-              variableNode = substitutionVariableNode;  ///
-
-        termNode = substitutionTermNode;  ///
-
         const { Term, Variable } = shim,
+              substitutionVariableNode = substitutionsVariableNodeQuery(substitutionNode),
+              variableNode = substitutionVariableNode,  ///
+              termNode = substitutionTermNode,  ///
               term = Term.fromTermNode(termNode, localContext),
               variable = Variable.fromVariableNode(variableNode, localContext),
-              string = stringFromTermAndVariable(term, variable);
+              string = stringFromTermAndVariable(term, variable, localContext);
 
-        termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
+        termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode);
       }
     }
 
     return termForVariableSubstitution;
   }
 
-  static fromTernAndVariable(term, variable) {
+  static fromTernAndVariable(term, variable, localContext) {
     let termNode = term.getNode();
 
     termNode = stripBracketsFromTerm(termNode); ///
 
-    const variableNode = variable.getNode(),
-          string = stringFromTermAndVariable(term, variable),
-          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
+    const string = stringFromTermAndVariable(term, variable, localContext),
+          variableNode = variable.getNode(),
+          substitutionNode = null,
+          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode);
 
     return termForVariableSubstitution;
   }
@@ -198,8 +188,9 @@ function transformVariableNode(variableNode, substitutions) {
   return transformedVariableNode;
 }
 
-function stringFromTermAndVariable(term, variable) {
-  const termString = term.getString(),
+function stringFromTermAndVariable(term, variable, localContext) {
+  const termNode = term.getNode(),
+        termString = localContext.nodeAsString(termNode),
         variableString = variable.getString(),
         string = `[${termString} for ${variableString}]`;
 

package/src/substitution.js

@@ -9,24 +9,22 @@ export default class Substitution {
     return this.string;
   }
 
-  isSimple() {
-    const simple = true;
+  getTermNode() {
+    const termNode = null;
 
-    return simple;
+    return termNode;
   }
 
-  isComplex() {
-    const simple = this.isSimple(),
-          complex = !simple;
+  getFrameNode() {
+    const frameNode = null;
 
-    return complex;
+    return frameNode;
   }
 
-  isResolved() {
-    const simple = this.isSimple(),
-          resolved = simple; ///
+  getStatementNode() {
+    const statementNode = null;
 
-    return resolved;
+    return statementNode;
   }
 
   getVariableNode() {
@@ -41,18 +39,49 @@ export default class Substitution {
     return metavariableNode;
   }
 
+  getSubstitutionNode() {
+    const substitutionNode = null;
+
+    return substitutionNode;
+  }
+
+  isSimple() {
+    const simple = true;
+
+    return simple;
+  }
+
+  isComplex() {
+    const simple = this.isSimple(),
+          complex = !simple;
+
+    return complex;
+  }
+
   isEqualTo(substitution) {
     const equalTo = false;
 
     return equalTo;
   }
 
+  resolve(substitutions, localContext) {
+    const resolved = true;
+
+    return resolved;
+  }
+
   matchTermNode(termNode) {
     const termNodeMatches = false;
 
     return termNodeMatches;
   }
 
+  matchFrameNode(frameNode) {
+    const frameNodeMatches = false;
+
+    return frameNodeMatches;
+  }
+
   matchVariableNode(variableNode) {
     const variableNodeMatches = false;