occam-verify-cli 0.0.1111 → 0.0.1112

package/src/{statement.js → dom/statement.js}

@@ -1,21 +1,25 @@
 "use strict";
 
-import shim from "./shim";
-import unifyMixins from "./mixins/statement/unify";
-import verifyMixins from "./mixins/statement/verify";
-import combinatorVerifier from "./verifier/combinator";
-import StatementNodeAndTokens from "./nodeAndTokens/statement";
-import unifyIndependentlyMixins from "./mixins/statement/unifyIndependenntly";
-
-import { unifyStatement } from "./utilities/unification";
-import { nodeQuery, nodesQuery } from "./utilities/query";
-import { STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
-
-const statementNodeQuery = nodeQuery("/*//statement"),
+import { arrayUtilities } from "necessary";
+
+import dom from "../dom";
+import verifyMixins from "../mixins/statement/verify";
+import combinatorVerifier from "../verifier/combinator";
+import StatementNodeAndTokens from "../nodeAndTokens/statement";
+
+import { domAssigned } from "../dom";
+import { unifyStatement } from "../utilities/unification";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
+import { definedAssertionFromStatement, subproofAssertionFromStatement, containedAssertionFromStatement } from "../utilities/verification";
+
+const { match, backwardsSome } = arrayUtilities;
+
+const statementNodeQuery = nodeQuery("/*/statement"),
       statementTermNodesQuery = nodesQuery("/statement//term"),
       statementFrameNodesQuery = nodesQuery("/statement//frame");
 
-class Statement {
+export default domAssigned(class Statement {
   constructor(string, node, tokens) {
     this.string = string;
     this.node = node;
@@ -35,13 +39,8 @@ class Statement {
   }
 
   isEqualTo(statement) {
-    let equalTo = false;
-
-    if (statement !== null) {
-      const statementString = statement.getString();
-
-      equalTo = (statementString === this.string);
-    }
+    const statementString = statement.getString(),
+          equalTo = (statementString === this.string);
 
     return equalTo;
   }
@@ -106,27 +105,38 @@ class Statement {
     return statementNodeMatches;
   }
 
-  unifyIndependently(substitutions, generalContext, specificContext) {
-    let unifiedIndependently;
+  unifySubproof(subproof, substitutions, generalContext, specificContext) {
+    let subproofUnified = false;
 
-    const statementString = this.string;  ///
+    const context = specificContext,  ///
+          statement = this, ///
+          subproofAssertion = subproofAssertionFromStatement(statement, context);
 
-    specificContext.trace(`Unifying the '${statementString}' statement independently...`);
+    if (subproofAssertion !== null) {
+      const subproofString = subproof.getString(),
+            subproofAssertionString = subproofAssertion.getString();
 
-    unifiedIndependently = unifyIndependentlyMixins.some((resolveMixin) => {
-      const statement = this, ///
-            unifiedIndependently = resolveMixin(statement, substitutions, generalContext, specificContext);
+      specificContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
 
-      if (unifiedIndependently) {
-        return true;
-      }
-    });
+      const subproofStatements = subproof.getStatements(),
+            subproofAssertionStatements = subproofAssertion.getStatements();
+
+      subproofUnified = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
+        const generalStatement = subproofAssertionStatement,  ///
+              specificStatement = subproofStatement,  ///
+              statementUnified = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);
+
+        if (statementUnified) {
+          return true;
+        }
+      });
 
-    if (unifiedIndependently) {
-      specificContext.debug(`...unified the '${statementString}' statement independently.`);
+      if (subproofUnified) {
+        specificContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+      }
     }
 
-    return unifiedIndependently;
+    return subproofUnified;
   }
 
   unifyStatement(statement, substitutions, generalContext, specificContext) {
@@ -148,41 +158,67 @@ class Statement {
     return statementUnified;
   }
 
-  verify(assignments, stated, context) {
-    let verified = false;
+  unifyIndependently(substitutions, generalContext, specificContext) {
+    let unifiedIndependently = false;
 
-    const statementString = this.string;  ///
+    const context = specificContext,  ///
+          statement = this; ///
 
-    context.trace(`Verifying the '${statementString}' statement...`);
+    const definedAssertion = definedAssertionFromStatement(statement, context),
+          containedAssertion = containedAssertionFromStatement(statement, context);
 
-    if (!verified) {
-      verified = verifyMixins.some((verifyMixin) => {
-        const statement = this, ///
-              verified = verifyMixin(statement, assignments, stated, context);
+    if ((definedAssertion !== null) || (containedAssertion !== null)) {
+      const statementString = this.string;
 
-        if (verified) {
-          return true;
-        }
-      });
-    }
+      specificContext.trace(`Unifying the '${statementString}' statement independently...`);
 
-    if (!verified) {
-      const unified = unifyMixins.some((unifyMixin) => {
-        const statement = this, ///
-              unified = unifyMixin(statement, assignments, stated, context);
+      if (definedAssertion !== null) {
+        const definedAssertionUnifiedIndependently = definedAssertion.unifyIndependently(substitutions, context);
 
-        if (unified) {
-          return true;
-        }
-      });
+        unifiedIndependently = definedAssertionUnifiedIndependently; ///
+      }
 
-      verified = unified; ///
-    }
+      if (containedAssertion !== null) {
+        const containedAssertionUnifiedIndependently = containedAssertion.unifyIndependently(substitutions, context);
 
-    if (verified) {
-      context.debug(`...verified the '${statementString}' statement.`);
+        unifiedIndependently = containedAssertionUnifiedIndependently; ///
+      }
+
+      if (unifiedIndependently) {
+        specificContext.debug(`...unified the '${statementString}' statement independently.`);
+      }
     }
 
+    return unifiedIndependently;
+  }
+
+  unifyWithProofSteps(proofSteps, context) {
+    let unifiedWithProofSteps;
+
+    unifiedWithProofSteps = backwardsSome(proofSteps, (proofStep) => {
+      const statement = this, ///
+            statementUnified =proofStep.unifyStatement(statement, context);
+
+      if (statementUnified) {
+        return true;
+      }
+    });
+
+    return unifiedWithProofSteps;
+  }
+
+  verify(assignments, stated, context) {
+    let verified;
+
+    verified = verifyMixins.some((verifyMixin) => {
+      const statement = this, ///
+            verified = verifyMixin(statement, assignments, stated, context);
+
+      if (verified) {
+        return true;
+      }
+    });
+
     return verified;
   }
 
@@ -235,6 +271,8 @@ class Statement {
     return json;
   }
 
+  static name = "Statement";
+
   static fromJSON(json, fileContext) {
     const { string } = json,
           context = fileContext,  ///
@@ -246,6 +284,20 @@ class Statement {
     return statement;
   }
 
+  static fromPremiseNode(premiseNode, fileContext) {
+    const node = premiseNode, ///
+          statement = statementFromNode(node, fileContext);
+
+    return statement;
+  }
+
+  static fromProofStepNode(proofStepNode, fileContext) {
+    const node = proofStepNode, ///
+          statement = statementFromNode(node, fileContext);
+
+    return statement;
+  }
+
   static fromStatementNode(statementNode, context) {
     let statement = null;
 
@@ -260,12 +312,23 @@ class Statement {
     return statement;
   }
 
-  static fromDefinedAssertionNode(definedAssertionNode, context) {
-    const statementNode = statementNodeQuery(definedAssertionNode),
-          node = statementNode, ///
-          tokens = context.nodeAsTokens(node),
-          string = context.tokensAsString(tokens),
-          statement = new Statement(string, node, tokens);
+  static fromConclusionNode(conclusionNode, fileContext) {
+    const node = conclusionNode, ///
+          statement = statementFromNode(node, fileContext);
+
+    return statement;
+  }
+
+  static fromConsequentNode(consequentNode, fileContext) {
+    const node = consequentNode, ///
+          statement = statementFromNode(node, fileContext);
+
+    return statement;
+  }
+
+  static fromSuppositionNode(suppositionNode, fileContext) {
+    const node = suppositionNode, ///
+          statement = statementFromNode(node, fileContext);
 
     return statement;
   }
@@ -279,13 +342,21 @@ class Statement {
 
     return statement;
   }
-}
+});
 
-Object.assign(Statement.prototype, unifyMixins);
+function statementFromNode(node, fileContext) {
+  let statement = null;
 
-Object.assign(shim, {
-  Statement
-});
+  const statementNode = statementNodeQuery(node);
 
-export default Statement;
+  if (statementNode !== null) {
+    const { Statement } = dom,
+          node = statementNode, ///
+          tokens = fileContext.nodeAsTokens(node),
+          string = fileContext.tokensAsString(tokens);
+
+    statement = new Statement(string, node, tokens);
+  }
 
+  return statement;
+}

package/src/{subDerivation.js → dom/subDerivation.js}

@@ -2,15 +2,16 @@
 
 import { arrayUtilities } from "necessary";
 
-import shim from "./shim";
+import dom from "../dom";
 
-import { nodesQuery } from "./utilities/query";
+import { nodesQuery } from "../utilities/query";
+import { domAssigned } from "../dom";
 
 const { last } = arrayUtilities;
 
 const proofStepNodesQuery = nodesQuery("/subDerivation/proofStep|lastProofStep");
 
-class SubDerivation {
+export default domAssigned(class SubDerivation {
   constructor(proofSteps) {
     this.proofSteps = proofSteps;
   }
@@ -29,9 +30,9 @@ class SubDerivation {
     let verified;
 
     verified = this.proofSteps.every((proofStep) => { ///
-      const proofStepVerified = proofStep.verify(substitutions, context);
+      const proofStepVerifiedAndUnified = proofStep.verifyAndUnify(substitutions, context);
 
-      if (proofStepVerified) {
+      if (proofStepVerifiedAndUnified) {
         return true;
       }
     });
@@ -39,8 +40,10 @@ class SubDerivation {
     return verified;
   }
 
+  static name = "SubDerivation";
+
   static fromSubDerivationNode(subDerivationNode, fileContext) {
-    const { ProofStep } = shim,
+    const { ProofStep } = dom,
           proofStepNodes = proofStepNodesQuery(subDerivationNode),
           proofSteps = proofStepNodes.map((proofStepNode) => {
             const proofStep = ProofStep.fromProofStepNode(proofStepNode, fileContext);
@@ -51,10 +54,4 @@ class SubDerivation {
 
     return subDerivation;
   }
-}
-
-Object.assign(shim, {
-  SubDerivation
 });
-
-export default SubDerivation;

package/src/{subproof.js → dom/subproof.js}

@@ -1,20 +1,17 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
+import dom from "../dom";
+import LocalContext from "../context/local";
 
-import shim from "./shim";
-import LocalContext from "./context/local";
+import { domAssigned } from "../dom";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+import { subproofStringFromSubproofNode } from "../utilities/subproof";
 
-import { unifyStatement } from "./utilities/unification";
-import { nodeQuery, nodesQuery } from "./utilities/query";
-import { subproofStringFromSubproofNode } from "./utilities/subproof";
-
-const { match } = arrayUtilities;
-
-const suppositionNodesQuery = nodesQuery("/subproof/supposition"),
+const subproofNodeQuery = nodeQuery("/proofStep/subproof"),
+      suppositionNodesQuery = nodesQuery("/subproof/supposition"),
       subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
 
-class Subproof {
+export default domAssigned(class Subproof {
   constructor(string, suppositions, subDerivation) {
     this.string = string;
     this.suppositions = suppositions;
@@ -55,34 +52,6 @@ class Subproof {
     return statements;
   }
 
-  unifySubproofAssertion(subproofAssertion, substitutions, generalContext, specificContext) {
-    let subproofAssertionUnified;
-
-    const subproofString = this.string,
-          subproofAssertionString = subproofAssertion.getString();
-
-    specificContext.trace(`Unifying the '${subproofAssertionString}' subproof assertion with the '${subproofString}' subproof...`);
-
-    const subproofStatements = this.getStatements(),
-          subproofAssertionStatements = subproofAssertion.getStatements();
-
-    subproofAssertionUnified = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
-      const generalStatement = subproofAssertionStatement,  ///
-            specificStatement = subproofStatement,  ///
-            statementUnified = unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext);
-
-      if (statementUnified) {
-        return true;
-      }
-    });
-
-    if (subproofAssertionUnified) {
-      specificContext.trace(`...unified the '${subproofAssertionString}' subproof assertion with the '${subproofString}' subproof.`);
-    }
-
-    return subproofAssertionUnified;
-  }
-
   verify(substitutions, context) {
     let subproofVerified = false;
 
@@ -109,11 +78,15 @@ class Subproof {
     return subproofVerified;
   }
 
-  static fromSubproofNode(subproofNode, fileContext) {
+  static name = "Subproof";
+
+  static fromProofStepNode(proofStepNode, fileContext) {
     let subproof = null;
 
+    const subproofNode = subproofNodeQuery(proofStepNode);
+
     if (subproofNode !== null) {
-      const { Supposition, SubDerivation } = shim,
+      const { Supposition, SubDerivation } = dom,
             subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
             suppositionNodes = suppositionNodesQuery(subproofNode),
             subDerivationNode = subDerivationNodeQuery(subproofNode),
@@ -130,10 +103,4 @@ class Subproof {
 
     return subproof;
   }
-}
-
-Object.assign(shim, {
-  Subproof
 });
-
-export default Subproof;

package/src/dom/supposition.js

@@ -0,0 +1,173 @@
+"use strict";
+
+import dom from "../dom";
+
+import { domAssigned } from "../dom";
+import { assignAssignments } from "../utilities/assignments";
+import { subproofAssertionFromStatement } from "../utilities/verification";
+import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+
+export default domAssigned(class Supposition {
+  constructor(string, statement) {
+    this.string = string;
+    this.statement = statement;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  unifyIndependently(substitutions, generalContext, specificContext) {
+    let unifiedIndependently;
+
+    const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
+
+    unifiedIndependently = statementResolvedIndependently;  ///
+
+    return unifiedIndependently;
+  }
+
+  unifyProofStep(proofStep, substitutions, generalContext, specificContext) {
+    let proofStepUnified = false;
+
+    const subproof = proofStep.getSubproof(),
+          statement = proofStep.getStatement();
+
+    substitutions.snapshot();
+
+    if (subproof !== null) {
+      const subproofUnified = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
+
+      proofStepUnified = subproofUnified; ///
+    }
+
+    if (statement !== null) {
+      const statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+      proofStepUnified = statementUnified;  ///
+    }
+
+    if (proofStepUnified) {
+      substitutions.resolve(generalContext, specificContext);
+    }
+
+    const context = specificContext;  ///
+
+    proofStepUnified ?
+      substitutions.continue() :
+        substitutions.rollback(context);
+
+    return proofStepUnified;
+  }
+
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
+    let statementUnified;
+
+    const supposition = this, ///
+          suppositionString = supposition.getString(),
+          statementString = statement.getString();
+
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
+
+    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+    if (statementUnified) {
+      specificContext.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
+    }
+
+    return statementUnified;
+  }
+
+  unifySubproof(subproof, substitutions, generalContext, specificContext) {
+    let subproofUnified = false;
+
+    const supposition = this, ///
+          subproofString = subproof.getString(),
+          suppositionStatement = supposition.getStatement(),
+          suppositionStatementString = suppositionStatement.getString();
+
+    specificContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
+
+    const context = generalContext,
+          subproofAssertion = subproofAssertionFromStatement(this.statement, context);
+
+    if (subproofAssertion !== null) {
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+    }
+
+    if (subproofUnified) {
+      specificContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
+    }
+
+    return subproofUnified;
+  }
+
+  verify(context) {
+    let verified = false;
+
+    const suppositionString = this.string; ///
+
+    if (this.statement !== null) {
+      context.trace(`Verifying the '${suppositionString}' supposition...`);
+
+      const stated = true,
+            assignments = [],
+            statementVerified = this.statement.verify(assignments, stated, context);
+
+      if (statementVerified) {
+        const assignmentsAssigned = assignAssignments(assignments, context);
+
+        if (assignmentsAssigned) {
+          const { ProofStep } = dom,
+                proofStep = ProofStep.fromStatement(this.statement, context);
+
+          context.addProofStep(proofStep);
+
+          verified = true;
+        }
+      }
+
+      if (verified) {
+        context.debug(`...verified the '${suppositionString}' supposition.`);
+      }
+    } else {
+      context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`);
+    }
+
+    return verified;
+  }
+
+  toJSON() {
+    const statementJSON = statementToStatementJSON(this.statement),
+          statement = statementJSON,  ///
+          json = {
+            statement
+          };
+
+    return json;
+  }
+
+  static name = "Supposition";
+
+  static fromJSON(json, fileContext) {
+    const statement = statementFromJSON(json, fileContext),
+          string = statement.getString(),
+          supposition = new Supposition(string, statement);
+
+    return supposition;
+  }
+
+  static fromSuppositionNode(suppositionNode, fileContext) {
+    const { Statement } = dom,
+          statement = Statement.fromSuppositionNode(suppositionNode, fileContext),
+          statementString = statement.getString(),
+          string = statementString, ///
+          supposition = new Supposition(string, statement);
+
+    return supposition
+  }
+});