occam-verify-cli 0.0.1061 → 0.0.1065

package/src/proofStep.js

@@ -71,7 +71,7 @@ class ProofStep {
 
       verified = qualifiedStatementVerified;  ///
     } else if (this.unqualifiedStatement !== null) {
-      const stated = true,
+      const stated = false,
             assignments = [],
             unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
 

package/src/statement/unqualified.js

@@ -45,6 +45,23 @@ export default class UnqualifiedStatement {
     return verified;
   }
 
+  unifyStatement(statement, substitutions, fileContext, localContext) {
+    let statementUnified;
+
+    const statementString = statement.getString(),
+          unqualifiedStatementString = this.getString();  ///
+
+    localContext.trace(`Unifying the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement...`);
+
+    statementUnified = this.statement.unifyStatement(statement, substitutions, fileContext, localContext);
+
+    if (statementUnified) {
+      localContext.debug(`...unified the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement.`);
+    }
+
+    return statementUnified;
+  }
+
   toJSON() {
     const statementJSON = this.statement.toJSON(),
           statement = statementJSON,  ///

package/src/statement.js

@@ -3,17 +3,23 @@
 import shim from "./shim";
 import unifyMixins from "./mixins/statement/unify";
 import verifyMixins from "./mixins/statement/verify";
-import StatementSubstitution from "./substitution/statement";
+import LocalContext from "./context/local";
+import metaLevelUnifier from "./unifier/metaLevel";
 import statementAsCombinatorVerifier from "./verifier/statementAsCombinator";
 
+import { nodeQuery, nodesQuery } from "./utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
 import { statementNodeFromStatementString } from "./utilities/node";
 
+const statementNodeQuery = nodeQuery("/*//statement"),
+      substitutionNodeQuery = nodeQuery("/statement/substitution"),
+      statementVariableNodesQuery = nodesQuery("/statement//variable"),
+      statementMetavariableNodesQuery = nodesQuery("/statement//metavariable");
+
 class Statement {
-  constructor(string, node, substitution) {
+  constructor(string, node) {
     this.string = string;
     this.node = node;
-    this.substitution = substitution;
   }
 
   getString() {
@@ -24,10 +30,6 @@ class Statement {
     return this.node;
   }
 
-  getSubstitution() {
-    return this.substitution;
-  }
-
   isEqualTo(statement) {
     const node = statement.getNode(),
           matches = this.node.match(node),
@@ -36,6 +38,60 @@ class Statement {
     return equalTo;
   }
 
+  isVariableContained(variable, localContext) {
+    let variableContained;
+
+    const variableString = variable.getString(),
+          statementString = this.string;  ///
+
+    localContext.trace(`The '${variableString}' variable is contained in hte '${statementString}' statement...`);
+
+    const variableNode = variable.getNode(),
+          statementNode = this.node,
+          statementVariableNodes = statementVariableNodesQuery(statementNode);
+
+    variableContained = statementVariableNodes.some((statementVariableNode) => {  ///
+      const variableNodeMatchesStatementVariableNode = variableNode.match(statementVariableNode);
+
+      if (variableNodeMatchesStatementVariableNode) {
+        return true;
+      }
+    });
+
+    if (variableContained) {
+      localContext.debug(`...the '${variableString}' variable is contained in hte '${statementString}' statement.`);
+    }
+
+    return variableContained;
+  }
+
+  isMetavariableContained(metavariable, localContext) {
+    let metavariableContained;
+
+    const metavariableString = metavariable.getString(),
+          statementString = this.string;  ///
+
+    localContext.trace(`The '${metavariableString}' metavariable is contained in hte '${statementString}' statement...`);
+
+    const metavariableNode = metavariable.getNode(),
+          statementNode = this.node,
+          statementMetavariableNodes = statementMetavariableNodesQuery(statementNode);
+
+    metavariableContained = statementMetavariableNodes.some((statementMetavariableNode) => {  ///
+      const metavariableNodeMatchesStatementMetavariableNode = metavariableNode.match(statementMetavariableNode);
+
+      if (metavariableNodeMatchesStatementMetavariableNode) {
+        return true;
+      }
+    });
+
+    if (metavariableContained) {
+      localContext.debug(`...the '${metavariableString}' metavariable is contained in hte '${statementString}' statement.`);
+    }
+
+    return metavariableContained;
+  }
+
   verify(assignments, stated, localContext) {
     let verified = false;
 
@@ -96,7 +152,7 @@ class Statement {
     const metaTypeString = metaType.getString(),
           statementString = this.string;  ///
 
-    localContext.trace(`Verifying the '${statementString}' given the '${metaTypeString}' meta-type...`);
+    localContext.trace(`Verifying the '${statementString}' statement given the '${metaTypeString}' meta-type...`);
 
     const metaTypeName = metaType.getName();
 
@@ -107,20 +163,41 @@ class Statement {
     }
 
     if (verifiedGivenMetaType) {
-      localContext.debug(`...verified the '${statementString}' given the '${metaTypeString}' meta-type.`);
+      localContext.debug(`...verified the '${statementString}' statement given the '${metaTypeString}' meta-type.`);
     }
 
     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 substitutionJSON = (this.substitution !== null) ?
-                                this.substitution.toJSON() :
-                                  null,
-          substitution = substitutionJSON,  ///
-          string = this.string, ///
+    const string = this.string, ///
           json = {
-            substitution,
             string
           };
 
@@ -133,17 +210,8 @@ class Statement {
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
           statementNode = statementNodeFromStatementString(statementString, lexer, parser),
-          node = statementNode;  ///
-
-    let { substitution } = json;
-
-    json = substitution;  ///
-
-    const statementSubstitution = StatementSubstitution.fromJSON(json, fileContext);
-
-    substitution = statementSubstitution; ///
-
-    const statement = new Statement(string, node, substitution);
+          node = statementNode,  ///
+          statement = new Statement(string, node);
 
     return statement;
   }
@@ -153,22 +221,38 @@ class Statement {
 
     if (statementNode !== null) {
       const node = statementNode, ///
-            string = localContext.nodeAsString(node),
-            statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext),
-            substitution = statementSubstitution; ///
+            string = localContext.nodeAsString(node);
 
-      statement = new Statement(string, node, substitution);
+      statement = new Statement(string, node);
     }
 
     return statement;
   }
+
+  static fromDefinedAssertionNode(definedAssertionNode, localContext) {
+    const statementNode = statementNodeQuery(definedAssertionNode),
+          node = statementNode, ///
+          string = localContext.nodeAsString(node),
+          statement = new Statement(string, node);
+
+    return statement;
+  }
+
+  static fromContainedAssertionNode(containedAssertionNode, localContext) {
+    const statementNode = statementNodeQuery(containedAssertionNode),
+          node = statementNode, ///
+          string = localContext.nodeAsString(node),
+          statement = new Statement(string, node);
+
+    return statement;
+  }
 }
 
+Object.assign(Statement.prototype, unifyMixins);
+
 Object.assign(shim, {
   Statement
 });
 
-Object.assign(Statement.prototype, unifyMixins);
-
 export default Statement;
 

package/src/substitution/statement.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import Substitution from "../substitution";
+import substitutionVerifier from "../verifier/substitution";
 
 import { nodeQuery } from "../utilities/query";
 import { substitutionNodeFromSubstitutionString } from "../utilities/node";
@@ -18,6 +19,25 @@ export default class StatementSubstitution extends Substitution {
     return this.node;
   }
 
+  verify(assignments, stated, localContext) {
+    let verified;
+
+    const statementSubstitutionString = this.string;  ///
+
+    localContext.trace(`Verifying the '${statementSubstitutionString}' statement substitution...`);
+
+    const substitutionNode = this.node, ///
+          substitutionVerified = substitutionVerifier.verify(substitutionNode, assignments, stated, localContext);
+
+    verified = substitutionVerified;  ///
+
+    if (verified) {
+      localContext.debug(`...verified the '${statementSubstitutionString}' statement substitution.`);
+    }
+
+    return verified;
+  }
+
   toJSON() {
     const string = this.getString(),
           json = {
@@ -50,10 +70,10 @@ export default class StatementSubstitution extends Substitution {
     const substitutionNode = substitutionNodeQuery(statementNode);
 
     if (substitutionNode) {
-      const node = substitutionNode,
+      const node = substitutionNode,  ///
             string = fileContext.nodeAsString(substitutionNode);
 
-      statementSubstitution = new Substitution(string, node);
+      statementSubstitution = new StatementSubstitution(string, node);
     }
 
     return statementSubstitution;

package/src/substitution/statementForMetavariable.js

@@ -81,7 +81,7 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     statement = Statement.fromStatementNode(statementNode, localContext); ///
 
     const metavariableNode = metavariable.getNode(),
-          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
+          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution);
 
     substitution = substitutionFromSubstitution(substitution, localContext);
 
@@ -91,53 +91,46 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 }
 
-function stringFromStatementAndMetavariable(statement, metavariable) {
-  const statementString = statement.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${statementString} for ${metavariableString}]`;
+function substitutionFromSubstitution(substitution, localContext) {
+  if (substitution === null) {
+    const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitution(substitution, localContext);
 
-  return string;
-}
+    if (termForVariableSubstitution !== null) {
+      substitution = termForVariableSubstitution; ///
+    }
+  }
 
+  if (substitution === null) {
+    const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitution(substitution, localContext);
 
-function substitutionFromSubstitution(substitution, localContextA, localContextB) {
-  // let substitution = null;
+    if (frameForMetavariableSubstitution !== null) {
+      substitution = frameForMetavariableSubstitution;  ///
+    }
+  }
 
-  debugger
+  return substitution;
+}
 
-  // if (substitution === null) {
-  //   const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitution(substitutionNode, localContextA, localContextB);
-  //
-  //   if (termForVariableSubstitution !== null) {
-  //     substitution = termForVariableSubstitution; ///
-  //   }
-  // }
-  //
-  // if (substitution === null) {
-  //   const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitution(substitutionNode, localContextA, localContextB);
-  //
-  //   if (frameForMetavariableSubstitution !== null) {
-  //     substitution = frameForMetavariableSubstitution;  ///
-  //   }
-  // }
+function stringFromStatementAndMetavariable(statement, metavariable) {
+  const statementString = statement.getString(),
+        metavariableString = metavariable.getString(),
+        string = `[${statementString} for ${metavariableString}]`;
 
-  return substitution;
+  return string;
 }
 
-function stringFromStatementMetavariableAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB) {
+function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution) {
   let string;
 
-  const statementNodeB = statementNode,  ///
-        statementStringB = localContextB.nodeAsString(statementNodeB),
-        metavariableNodeA = metavariableNode,  ///
-        metavariableStringA = localContextA.nodeAsString(metavariableNodeA);
+  const statementString = statement.getString(),
+        metavariableString = metavariable.getString();
 
   if (substitution === null) {
-    string = `[${statementStringB} for ${metavariableStringA}]`;
+    string = `[${statementString} for ${metavariableString}]`;
   } else {
-    const substitutionString = substitution.asString(localContextA, localContextA);
+    const substitutionString = substitution.getString();
 
-    string = `[${statementStringB} for ${metavariableStringA}${substitutionString}]`;
+    string = `[${statementString} for ${metavariableString}${substitutionString}]`;
   }
 
   return string;

package/src/substitution/termForVariable.js

@@ -83,7 +83,7 @@ export default class TermForVariableSubstitution extends Substitution {
     return unifiedWithEquivalence;
   }
 
-  static fromSubstitution(substitution) {
+  static fromSubstitution(substitution, localContext) {
     let termForVariableSubstitution = null;
 
     const substitutionNode = substitution.getNode();
@@ -91,30 +91,33 @@ export default class TermForVariableSubstitution extends Substitution {
     let substitutionTermNode = substitutionTermNodeQuery(substitutionNode);
 
     if (substitutionTermNode !== null) {
-      let termNode = substitutionTermNode;  ///
-
-      termNode = stripBracketsFromTerm(termNode); ///
+      let termNode;
 
       const substitutionVariableNode = substitutionsVariableNodeQuery(substitutionNode),
             variableNode = substitutionVariableNode;  ///
 
-      termForVariableSubstitution = new TermForVariableSubstitution(termNode, variableNode);
+      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 fromTernAndVariable(term, variable, localContext) {
+  static fromTernAndVariable(term, variable) {
     let termNode = term.getNode();
 
     termNode = stripBracketsFromTerm(termNode); ///
 
-    const { Term } = shim;
-
-    term = Term.fromTermNode(termNode, localContext); ///
-
-    const string = stringFromTermAndVariable(term, variable),
-          variableNode = variable.getNode(),
+    const variableNode = variable.getNode(),
+          string = stringFromTermAndVariable(term, variable),
           termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
 
     return termForVariableSubstitution;

package/src/supposition.js

@@ -1,8 +1,6 @@
 "use strict";
 
 import shim from "./shim";
-import LocalContext from "./context/local";
-import metaLevelUnifier from "./unifier/metaLevel";
 import SubproofAssertion from "./assertion/subproof";
 import UnqualifiedStatement from "./statement/unqualified";
 
@@ -111,26 +109,15 @@ export default class Supposition {
   unifyStatement(statement, substitutions, localContext) {
     let statementUnified;
 
-    const supposition = this, ///
-          statementString = statement.getString(),
-          suppositionStatement = supposition.getStatement(),
-          suppositionStatementString = suppositionStatement.getString();
-
-    localContext.trace(`Unifying the '${statementString}' statement with the supposition's '${suppositionStatementString}' statement...`);
+    const statementString = statement.getString(),
+          suppositionString = this.getString();
 
-    const statementNode = statement.getNode(),
-          suppositionStatementNode = suppositionStatement.getNode(),
-          nodeA = suppositionStatementNode,  ///
-          nodeB = statementNode,  ///
-          fileContextA = this.fileContext,  ///
-          localContextA = LocalContext.fromFileContext(fileContextA),
-          localContextB = localContext, ///
-          unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+    localContext.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
 
-    statementUnified = unified; ///
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, this.fileContext, localContext);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the supposition's '${suppositionStatementString}' statement.`);
+      localContext.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
     }
 
     return statementUnified;

package/src/term.js

@@ -8,12 +8,15 @@ import verifyMixins from "./mixins/term/verify";
 import termAsConstructorVerifier from "./verifier/termAsConstructor";
 
 import { objectType } from "./type";
-import { nodesQuery } from "./utilities/query"
+import { nodeQuery, nodesQuery } from "./utilities/query"
 import { termNodeFromTermString } from "./utilities/node";
+import { variableNameFromVariableNode } from "./utilities/name";
 
 const { filter } = arrayUtilities;
 
-const variableNodesQuery = nodesQuery("//variable");
+const termNodeQuery = nodeQuery("/*/term[0]"),
+      variableNodeQuery = nodeQuery("/term/variable!"),
+      variableNodesQuery = nodesQuery("//variable");
 
 class Term {
   constructor(string, node, type) {
@@ -45,12 +48,27 @@ class Term {
     return matches;
   }
 
+  getVariable(localContext) {
+    let variable = null;
+
+    const variableNode = variableNodeQuery(this.node);
+
+    if (variableNode !== null) {
+      const variableName = variableNameFromVariableNode(variableNode);
+
+      variable = localContext.findVariableByVariableName(variableName);
+    }
+
+    return variable;
+  }
+
   getVariables(localContext) {
     const variables = [],
           variableNodes = variableNodesQuery(this.node);
 
     variableNodes.forEach((variableNode) => {
-      const variable = localContext.findVariableByVariableNode(variableNode),
+      const variableName = variableNameFromVariableNode(variableNode),
+            variable = localContext.findVariableByVariableName(variableName),
             variablesIncludesVariable = variables.includes(variable);
 
       if (!variablesIncludesVariable) {
@@ -263,6 +281,46 @@ class Term {
 
     return term;
   }
+
+  static fromDefinedAssertionNode(definedAssertionNode, localContext) {
+    let term = null;
+
+    const termNode = termNodeQuery(definedAssertionNode);
+
+    if (termNode !== null) {
+      const variableNode = variableNodeQuery(termNode);
+
+      if (variableNode !== null) {
+        const node = termNode,  ///
+              string = localContext.nodeAsString(node),
+              type = null;
+
+        term = new Term(string, node, type);
+      }
+    }
+
+    return term;
+  }
+
+  static fromContainedAssertionNode(containedAssertionNode, localContext) {
+    let term = null;
+
+    const termNode = termNodeQuery(containedAssertionNode);
+
+    if (termNode !== null) {
+      const variableNode = variableNodeQuery(termNode);
+
+      if (variableNode !== null) {
+        const node = termNode,  ///
+              string = localContext.nodeAsString(node),
+              type = null;
+
+        term = new Term(string, node, type);
+      }
+    }
+
+    return term;
+  }
 }
 
 Object.assign(shim, {

package/src/unifier/intrinsicLevel.js

@@ -11,15 +11,15 @@ const termNodeQuery = nodeQuery("/term!"),
 
 class IntrinsicLevelUnifier extends Unifier {
   unify(nodeA, nodeB, substitutions, localContextA, localContextB) {
-    let unified;
+    let unifiedAtIntrinsicLevel;
 
     const nonTerminalNodeA = nodeA, ///
           nonTerminalNodeB = nodeB, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB);
 
-    unified = nonTerminalNodeUnified; ///
+    unifiedAtIntrinsicLevel = nonTerminalNodeUnified; ///
 
-    return unified;
+    return unifiedAtIntrinsicLevel;
   }
 
   static maps = [

package/src/unifier/metaLevel.js

@@ -16,15 +16,15 @@ const termNodeQuery = nodeQuery("/term!"),
 
 class MetaLevelUnifier extends Unifier {
   unify(nodeA, nodeB, substitutions, localContextA, localContextB) {
-    let unified;
+    let unifiedAtMetaLevel;
 
     const nonTerminalNodeA = nodeA, ///
           nonTerminalNodeB = nodeB, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB);
 
-    unified = nonTerminalNodeUnified; ///
+    unifiedAtMetaLevel = nonTerminalNodeUnified; ///
 
-    return unified;
+    return unifiedAtMetaLevel;
   }
 
   static maps = [
@@ -39,30 +39,23 @@ class MetaLevelUnifier extends Unifier {
         if (matches) {
           statementUnified = true;
         } else {
-          const { Statement } = shim,
-                statementB = Statement.fromStatementNode(statementNodeB, localContextB),
-                statementMetavariableNodeA = statementMetavariableNodeQuery(statementNodeA);
+          const statementNode = statementNodeA, ///
+                statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
 
-          if (statementMetavariableNodeA !== null) {
-            let statement;
-
-            const statementA = Statement.fromStatementNode(statementNodeA, localContextA);
-
-            statement = statementA; ///
-
-            const substitution = statement.getSubstitution();
-
-            statement = statementB; ///
-
-            const localContext = localContextB, ///
-                  metavariableNode = statementMetavariableNodeA,  ///
+          if (statementMetavariableNode !== null) {
+            const { Statement } = shim,
+                  metavariableNode = statementMetavariableNode, ///
                   metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-                  metavariable = localContextA.findMetavariableByMetavariableName(metavariableName);
+                  metavariable = localContextA.findMetavariableByMetavariableName(metavariableName),
+                  substitution = substitutionA,  ///
+                  localContext = localContextB, ///
+                  statementNode = statementNodeB, ///
+                  statement = Statement.fromStatementNode(statementNode, localContext);
 
             if (substitution === null) {
               statementUnified = metavariable.unifyStatement(statement, substitutions, localContext);
             } else {
-              const statementUnifiedGivenSubstitution = metavariableNode.unifyStatementGivenSubstitution(statement, substitution, substitutions, localContext);
+              const statementUnifiedGivenSubstitution = metavariable.unifyStatementGivenSubstitution(statement, substitution, substitutions, localContext);
 
               statementUnified = statementUnifiedGivenSubstitution; ///
             }
@@ -116,6 +109,8 @@ const metaLevelUnifier = new MetaLevelUnifier();
 export default metaLevelUnifier;
 
 function unifyStatementWithStatement(statementNodeA, statementNodeB, substitutions, localContextA, localContextB) {
+  substitutionA = null;
+
   const nonTerminalNodeA = statementNodeA, ///
         nonTerminalNodeB = statementNodeB, ///
         nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),