occam-verify-cli 0.0.1002 → 0.0.1005

package/src/statement.js

@@ -0,0 +1,179 @@
+"use strict";
+
+import shim from "./shim";
+import unifyMixins from "./mixins/statement/unify";
+import verifyMixins from "./mixins/statement/verify";
+import statementAsCombinatorVerifier from "./verifier/statementAsCombinator";
+
+import { statementNodeFromStatementString } from "./utilities/node";
+import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
+
+class Statement {
+  constructor(string, node) {
+    this.string = string;
+    this.node = node;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  isEqualTo(statement) {
+    const node = statement.getNode(),
+          matches = this.node.match(node),
+          equalTo = matches;  ///
+
+    return equalTo;
+  }
+
+  verify(assignments, stated, localContext) {
+    let verified = false;
+
+    const statement = this, ///
+          statementString = this.string;  ///
+
+    localContext.trace(`Verifying the '${statementString}' statement...`);
+
+    if (!verified) {
+      verified = unifyMixins.some((unifyMixin) => { ///
+        const unified = unifyMixin(statement, assignments, stated, localContext);
+
+        if (unified) {
+          return true;
+        }
+      });
+    }
+
+    if (!verified) {
+      verified = verifyMixins.some((verifyMixin) => {
+        const verified = verifyMixin(statement, assignments, stated, localContext);
+
+        if (verified) {
+          return true;
+        }
+      });
+    }
+
+    if (verified) {
+      localContext.debug(`...verified the '${statementString}' statement.`);
+    }
+
+    return verified;
+  }
+
+  unifyWithMetaType(metaType, assignments, stated, localContext) {
+    let unifiedWithMetaType;
+
+    const verifiedGivenMetaType = this.verifyGivenMetaType(metaType, assignments, stated, localContext);
+
+    unifiedWithMetaType = verifiedGivenMetaType;  ///
+
+    return unifiedWithMetaType;
+  }
+
+  verifyAsCombinator(localContext) {
+    let verifiedAsCombinator;
+
+    const statementNode = this.node,  ///
+          statementString = this.string;  ///
+
+    localContext.trace(`Verifying the '${statementString}' statement as a combinator...`);
+
+    verifiedAsCombinator = statementAsCombinatorVerifier.verifyStatement(statementNode, localContext);
+
+    if (verifiedAsCombinator) {
+      localContext.debug(`...verified the '${statementString}' statement as a combinator.`, statementNode);
+    }
+
+    return verifiedAsCombinator;
+  }
+
+  verifyGivenMetaType(metaType, assignments, stated, localContext) {
+    let verifiedGivenMetaType;
+
+    const metaTypeName = metaType.getName();
+
+    switch (metaTypeName) {
+      case FRAME_META_TYPE_NAME:
+      case REFERENCE_META_TYPE_NAME: {
+        debugger
+
+        // verifiedGivenMetaType = false;
+        //
+        // const metavariableNode = metavariableNodeQuery(statementNode);
+        //
+        // if (metavariableNode !== null) {
+        //   const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        //     metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+        //
+        //   if (metavariable !== null) {
+        //     const metavariableMetaType = metavariable.getMetaType();
+        //
+        //     if (metavariableMetaType === metaType) {
+        //       verifiedGivenMetaType = true;
+        //     }
+        //   }
+        // }
+
+        break;
+      }
+
+      case STATEMENT_META_TYPE_NAME: {
+        const verified = this.verify(assignments, stated, localContext)
+
+        verifiedGivenMetaType = verified; ///
+
+        break;
+      }
+    }
+
+    return verifiedGivenMetaType;
+  }
+
+  toJSON() {
+    const string = this.string, ///
+          json = {
+            string
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    const { string } = json,
+          statementString = string, ///
+          lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
+          node = statementNode,  ///
+          statement = new Statement(string, node);
+
+    return statement;
+  }
+
+  static fromStatementNode(statementNode, localContext) {
+    let statement;
+
+    if (statementNode !== null) {
+      const node = statementNode, ///
+            string = localContext.nodeAsString(node);
+
+      statement = new Statement(string, node);
+    }
+
+    return statement;
+  }
+}
+
+Object.assign(shim, {
+  Statement
+});
+
+Object.assign(Statement.prototype, unifyMixins);
+
+export default Statement;
+

package/src/subDerivation.js

@@ -0,0 +1,52 @@
+"use strict";
+
+import shim from "./shim";
+
+import { last } from "./utilities/array";
+import { nodesQuery } from "./utilities/query";
+
+const proofStepNodesQuery = nodesQuery("/subDerivation/proofStep|lastProofStep");
+
+export default class SubDerivation {
+  constructor(proofSteps) {
+    this.proofSteps = proofSteps;
+  }
+
+  getProofSteps() {
+    return this.proofSteps;
+  }
+
+  getLastProofStep() {
+    const lastProofStep = last(this.proofSteps);
+
+    return lastProofStep;
+  }
+
+  verify(substitutions, localContext) {
+    let verified;
+
+    verified = this.proofSteps.every((proofStep) => { ///
+      const proofStepVerified = proofStep.verify(substitutions, localContext);
+
+      if (proofStepVerified) {
+        return true;
+      }
+    });
+
+    return verified;
+  }
+
+  static fromSubDerivationNode(subDerivationNode, fileContext) {
+    const { ProofStep } = shim,
+          proofStepNodes = proofStepNodesQuery(subDerivationNode),
+          proofSteps = proofStepNodes.map((proofStepNode) => {
+            const proofStep = ProofStep.fromProofStepNode(proofStepNode, fileContext);
+
+            return proofStep;
+          }),
+          subDerivation = new SubDerivation(proofSteps);
+
+    return subDerivation;
+
+  }
+}

package/src/subproof.js

@@ -0,0 +1,99 @@
+"use strict";
+
+import Supposition from "./supposition";
+import LocalContext from "./context/local";
+import SubDerivation from "./subDerivation";
+
+import { nodeQuery, nodesQuery } from "./utilities/query";
+import {subproofNodeAsSubproofString, subproofStringFromSubproofNode} from "./utilities/subproof";
+
+const suppositionNodesQuery = nodesQuery("/subproof/supposition"),
+      subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
+
+export default class Subproof {
+  constructor(string, suppositions, subDerivation) {
+    this.string = string;
+    this.suppositions = suppositions;
+    this.subDerivation = subDerivation;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getSuppositions() {
+    return this.suppositions;
+  }
+
+  getSubDerivation() {
+    return this.subDerivation;
+  }
+
+  getLastProofStep() { return this.subDerivation.getLastProofStep(); }
+
+  getStatements() {
+    const lastProofStep = this.getLastProofStep(),
+          suppositionStatements = this.suppositions.map((supposition) => {
+            const suppositionStatement = supposition.getStatement();
+
+            return suppositionStatement;
+          }),
+          lastProofStepStatement = lastProofStep.getStatement(),
+          statements = [
+            ...suppositionStatements,
+            lastProofStepStatement
+          ];
+
+    return statements;
+  }
+
+
+  verify(substitutions, localContext) {
+    let subproofVerified = false;
+
+    localContext = LocalContext.fromLocalContext(localContext);  ///
+
+    const suppositionsVerified = this.suppositions.every((supposition) => {
+      const suppositionVerified = supposition.verify(localContext);
+
+      if (suppositionVerified) {
+        return true;
+      }
+    });
+
+    if (suppositionsVerified) {
+      const subDerivationVerified = this.subDerivation.verify(substitutions, localContext);
+
+      if (subDerivationVerified) {
+        subproofVerified = true;
+      }
+    }
+
+    return subproofVerified;
+  }
+
+  static fromSubproofNode(subproofNode, fileContext) {
+    let subproof = null;
+
+    if (subproofNode !== null) {
+      const subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
+            suppositionNodes = suppositionNodesQuery(subproofNode),
+            subDerivationNode = subDerivationNodeQuery(subproofNode),
+            string = subproofString,  ///
+            suppositions = suppositionNodes.map((suppositionNode) => {
+              const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
+
+              return supposition;
+            }),
+            subDerivation = SubDerivation.fromSubDerivationNode(subDerivationNode, fileContext);
+
+      subproof = new Subproof(string, suppositions, subDerivation);
+    }
+
+    return subproof;
+  }
+}

package/src/substitution/frameForMetavariable.js

@@ -9,8 +9,8 @@ const substitutionFrameNodeQuery = nodeQuery("/substitution/frame!"),
       substitutionMetavariableNodeQuery = nodeQuery("/substitution/metavariable!");
 
 export default class FrameForMetavariableSubstitution extends Substitution {
-  constructor(frameNode, metavariableNode) {
-    super();
+  constructor(string, frameNode, metavariableNode) {
+    super(string);
 
     this.frameNode = frameNode;
     this.metavariableNode = metavariableNode;
@@ -69,17 +69,7 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return metavariableNodeMatches;
   }
 
-  asString(localContextA, localContextB) {
-    const frameNodeB = this.frameNode,  ///
-          frameStringB = localContextB.nodeAsString(frameNodeB),
-          metavariableNodeA = this.metavariableNode,  ///
-          metavariableStringA = localContextA.nodeAsString(metavariableNodeA),
-          string = `[${frameStringB} for ${metavariableStringA}]`;
-
-    return string;
-  }
-
-  static fromSubstitutionNode(substitutionNode) {
+  static fromSubstitutionNode(substitutionNode, localContextA, localContextB) {
     let frameForMetavariableSubstitution = null;
 
     const substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
@@ -87,16 +77,18 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     if (substitutionFrameNode !== null) {
       const substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
             metavariableNode = substitutionMetavariableNode,  ///
-            frameNode = substitutionFrameNode;  ///
+            frameNode = substitutionFrameNode,  ///
+            string = stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB);
 
-      frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(frameNode, metavariableNode);
+        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode);
     }
 
     return frameForMetavariableSubstitution;
   }
 
-  static fromFrameNodeAndMetavariableNode(frameNode, metavariableNode) {
-    const frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(frameNode, metavariableNode);
+  static fromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB) {
+    const string = stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB),
+          frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode);
 
     return frameForMetavariableSubstitution;
   }
@@ -146,3 +138,14 @@ 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}]`;
+
+  return string;
+}
+

package/src/substitution/statementForMetavariable.js

@@ -7,8 +7,8 @@ import FrameForMetavariableSubstitution from "../substitution/frameForMetavariab
 import { stripBracketsFromStatement } from "../utilities/brackets";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
-  constructor(statementNode, metavariableNode, substitution) {
-    super();
+  constructor(string, statementNode, metavariableNode, substitution) {
+    super(string);
 
     this.statementNode = statementNode;
     this.metavariableNode = metavariableNode;
@@ -53,49 +53,32 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return metavariableNodeMatches;
   }
 
-  asString(localContextA, localContextB) {
-    let string;
-
-    const statementNodeB = this.statementNode,  ///
-          statementStringB = localContextB.nodeAsString(statementNodeB),
-          metavariableNodeA = this.metavariableNode,  ///
-          metavariableStringA = localContextA.nodeAsString(metavariableNodeA);
-
-    if (this.substitution === null) {
-      string = `[${statementStringB} for ${metavariableStringA}]`;
-    } else {
-      const substitutionString = this.substitution.asString(localContextA, localContextA);
-
-      string = `[${statementStringB} for ${metavariableStringA}${substitutionString}]`;
-    }
-
-    return string;
-  }
-
-  static fromStatementNodeAndMetavariableNode(statementNode, metavariableNode) {
+  static fromStatementNodeAndMetavariableNode(statementNode, metavariableNode, localContextA, localContextB) {
     statementNode = stripBracketsFromStatement(statementNode); ///
 
     const substitution = null,
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode, substitution);
+          string = stringFromStatementNodeMetavariableNodeAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB),
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statementNode, metavariableNode, substitution);
 
     return statementForMetavariableSubstitution;
   }
 
-  static fromStatementNodeMetavariableNodeAndSubstitutionNode(statementNode, metavariableNode, substitutionNode) {
+  static fromStatementNodeMetavariableNodeAndSubstitutionNode(statementNode, metavariableNode, substitutionNode, localContextA, localContextB) {
     statementNode = stripBracketsFromStatement(statementNode); ///
 
-    const substitution = substitutionFromSubstitutionNode(substitutionNode),
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode, substitution);
+    const substitution = substitutionFromSubstitutionNode(substitutionNode, localContextA, localContextB),
+          string = stringFromStatementNodeMetavariableNodeAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB),
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statementNode, metavariableNode, substitution);
 
     return statementForMetavariableSubstitution;
   }
 }
 
-function substitutionFromSubstitutionNode(substitutionNode) {
+function substitutionFromSubstitutionNode(substitutionNode, localContextA, localContextB) {
   let substitution = null;
 
   if (substitution === null) {
-    const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode);
+    const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode, localContextA, localContextB);
 
     if (termForVariableSubstitution !== null) {
       substitution = termForVariableSubstitution; ///
@@ -103,7 +86,7 @@ function substitutionFromSubstitutionNode(substitutionNode) {
   }
 
   if (substitution === null) {
-    const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitutionNode(substitutionNode);
+    const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitutionNode(substitutionNode, localContextA, localContextB);
 
     if (frameForMetavariableSubstitution !== null) {
       substitution = frameForMetavariableSubstitution;  ///
@@ -112,3 +95,22 @@ function substitutionFromSubstitutionNode(substitutionNode) {
 
   return substitution;
 }
+
+function stringFromStatementNodeMetavariableNodeAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB) {
+  let string;
+
+  const statementNodeB = statementNode,  ///
+        statementStringB = localContextB.nodeAsString(statementNodeB),
+        metavariableNodeA = metavariableNode,  ///
+        metavariableStringA = localContextA.nodeAsString(metavariableNodeA);
+
+  if (substitution === null) {
+    string = `[${statementStringB} for ${metavariableStringA}]`;
+  } else {
+    const substitutionString = substitution.asString(localContextA, localContextA);
+
+    string = `[${statementStringB} for ${metavariableStringA}${substitutionString}]`;
+  }
+
+  return string;
+}

package/src/substitution/termForVariable.js

@@ -10,8 +10,8 @@ const termVariableNodeQuery = nodeQuery("/term/variable!"),
       substitutionsVariableNodeQuery = nodeQuery("/substitution/variable!");
 
 export default class TermForVariableSubstitution extends Substitution {
-  constructor(termNode, variableNode) {
-    super();
+  constructor(string, termNode, variableNode) {
+    super(string);
 
     this.termNode = termNode;
     this.variableNode = variableNode;
@@ -88,16 +88,6 @@ export default class TermForVariableSubstitution extends Substitution {
     return unifiedWithEquivalence;
   }
 
-  asString(localContextA, localContextB) {
-    const termNodeB = this.termNode,  ///
-          termStringB = localContextB.nodeAsString(termNodeB),
-          variableNodeA = this.variableNode,  ///
-          variableStringA = localContextA.nodeAsString(variableNodeA),
-          string = `[${termStringB} for ${variableStringA}]`;
-
-    return string;
-  }
-
   static fromSubstitutionNode(substitutionNode) {
     let termForVariableSubstitution = null;
 
@@ -117,10 +107,11 @@ export default class TermForVariableSubstitution extends Substitution {
     return termForVariableSubstitution;
   }
 
-  static fromTernNodeAndVariableNode(termNode, variableNode) {
+  static fromTernNodeAndVariableNode(termNode, variableNode, localContextA, localContextB) {
     termNode = stripBracketsFromTerm(termNode); ///
 
-    const termForVariableSubstitution = new TermForVariableSubstitution(termNode, variableNode);
+    const string = stringFromTermNodeAndVariableNode(termNode, variableNode, localContextA, localContextB),
+          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
 
     return termForVariableSubstitution;
   }
@@ -170,3 +161,13 @@ function transformVariableNode(variableNode, substitutions) {
 
   return transformedVariableNode;
 }
+
+function stringFromTermNodeAndVariableNode(termNode, variableNode, localContextA, localContextB) {
+  const termNodeB = termNode,  ///
+        termStringB = localContextB.nodeAsString(termNodeB),
+        variableNodeA = variableNode,  ///
+        variableStringA = localContextA.nodeAsString(variableNodeA),
+        string = `[${termStringB} for ${variableStringA}]`;
+
+  return string;
+}

package/src/substitution.js

@@ -1,6 +1,14 @@
 "use strict";
 
 export default class Substitution {
+  constructor(string) {
+    this.string = string;
+  }
+
+  getString() {
+    return this.string;
+  }
+
   isSimple() {
     const simple = true;
 

package/src/substitutions.js

@@ -177,16 +177,15 @@ export default class Substitutions {
     return complexSubstitution;
   }
 
-  addSubstitution(substitution, localContextA, localContextB) {
+  addSubstitution(substitution, localContext) {
     this.array.push(substitution);
 
-    const substitutionNode = substitution.getNode(),
-          substitutionString = substitution.asString(localContextA, localContextB);
+    const substitutionString = substitution.getString();
 
-    localContextB.trace(`Added the ${substitutionString} substitution.`, substitutionNode);
+    localContext.trace(`Added the ${substitutionString} substitution.`);
   }
 
-  removeSubstitution(substitution, localContextA, localContextB) {
+  removeSubstitution(substitution, localContext) {
     const substitutionA = substitution; ///
 
     prune(this.array, (substitution) => {
@@ -198,15 +197,15 @@ export default class Substitutions {
     });
 
     const substitutionNode = substitution.getNode(),
-          substitutionString = substitution.asString(localContextA, localContextB);
+          substitutionString = substitution.getString();
 
-    localContextB.trace(`Removed the ${substitutionString} substitution.`, substitutionNode);
+    localContext.trace(`Removed the ${substitutionString} substitution.`, substitutionNode);
   }
 
-  unifyWithEquivalences(equivalences, localContextA, localContextB) {
+  unifyWithEquivalences(equivalences, localContext) {
     const unifiedWithEquivalences = this.everySubstitution((substitution) => {
       const substitutions = this, ///
-            substitutionUnifiedWithEquivalence = substitution.unifyWithEquivalences(equivalences, substitutions, localContextA, localContextB);
+            substitutionUnifiedWithEquivalence = substitution.unifyWithEquivalences(equivalences, substitutions, localContext);
 
       if (substitutionUnifiedWithEquivalence) {
         return true;
@@ -232,7 +231,7 @@ export default class Substitutions {
     ];
   }
 
-  rollback(localContextA, localContextB) {
+  rollback(localContext) {
     const array = [
       ...this.array
     ];
@@ -240,7 +239,7 @@ export default class Substitutions {
     rightDifference(this.savedArray, array);
 
     array.forEach((substitution) => {
-      this.removeSubstitution(substitution, localContextA, localContextB);
+      this.removeSubstitution(substitution, localContext);
     });
 
     this.array = [
@@ -254,9 +253,9 @@ export default class Substitutions {
     this.savedArray = null;
   }
 
-  asString(localContextA, localContextB) {
+  getString(localContextA, localContextB) {
     let string = this.array.reduce((string, substitution) => {
-      const substitutionString = substitution.asString(localContextA, localContextB);
+      const substitutionString = substitution.getString(localContextA, localContextB);
 
       string = (string === null) ?
                  substitutionString :