occam-verify-cli 0.0.1016 → 0.0.1020

package/src/reference.js

@@ -25,20 +25,20 @@ export default class Reference {
     return metavariableNode;
   }
 
-  verify(fileContext) {
-    let verified;
+  verifyAtTopLevel(fileContext) {
+    let verifiedAtTopLevel;
 
     const referenceString = this.getString(); ///
 
-    fileContext.trace(`Verifying the '${referenceString}' reference...`);
+    fileContext.trace(`Verifying the '${referenceString}' reference at top level...`);
 
-    verified = true;
+    verifiedAtTopLevel = true;
 
-    if (verified) {
-      fileContext.debug(`...verified the '${referenceString}' reference.`);
+    if (verifiedAtTopLevel) {
+      fileContext.debug(`...verified the '${referenceString}' reference at top level.`);
     }
 
-    return verified;
+    return verifiedAtTopLevel;
   }
 
   toJSON() {

package/src/rule.js

@@ -97,15 +97,15 @@ export default class Rule {
 
     this.fileContext.trace(`Verifying the '${labelsString}' rule...`);
 
-    const labelsVerified = this.labels.every((label) => {
-      const labelVVerified = label.verify(this.fileContext);
+    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
+      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
 
-      if (labelVVerified) {
+      if (labelVVerifiedAtTopLevel) {
         return true;
       }
     });
 
-    if (labelsVerified) {
+    if (labelsVerifiedAtTopLevel) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             premisesVerified = this.premises.every((premise) => {
               const premiseVerified = premise.verify(localContext);

package/src/ruleNames.js

@@ -1,6 +1,6 @@
 "use strict";
 
-export const TERM_RULE_NAME = "term";
+export const VARIABLE_RULE_NAME = "variable";
 export const METAVARIABLE_RULE_NAME = "metavariable";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";

package/src/statement/qualified.js

@@ -65,7 +65,7 @@ export default class QualifiedStatement {
     let unified;
 
     const qualifiedStatement = this,  ///
-          qualifiedStatementString = trim(this.string); ///
+          qualifiedStatementString = this.string; ///
 
     localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement...`);
 
@@ -86,13 +86,17 @@ export default class QualifiedStatement {
     let qualifiedStatement = null;
 
     if (qualifiedStatementNode !== null) {
+      let string;
       const statementNode = statementNodeQuery(qualifiedStatementNode),
             referenceNode = referenceNodeQuery(qualifiedStatementNode),
             localContext = LocalContext.fromFileContext(fileContext),
             statement = Statement.fromStatementNode(statementNode, localContext),
             reference = Reference.fromReferenceNode(referenceNode, fileContext),
-            node = qualifiedStatementNode,  ///
-            string = trim(fileContext.nodeAsString(node));  ///
+            node = qualifiedStatementNode;  ///
+
+      string = fileContext.nodeAsString(node);
+
+      string = trim(string);  ///
 
         qualifiedStatement = new QualifiedStatement(string, statement, reference);
     }

package/src/statement.js

@@ -5,8 +5,8 @@ import unifyMixins from "./mixins/statement/unify";
 import verifyMixins from "./mixins/statement/verify";
 import statementAsCombinatorVerifier from "./verifier/statementAsCombinator";
 
+import { STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
 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) {
@@ -39,13 +39,15 @@ class Statement {
     localContext.trace(`Verifying the '${statementString}' statement...`);
 
     if (!verified) {
-      verified = unifyMixins.some((unifyMixin) => { ///
+      const unified = unifyMixins.some((unifyMixin) => {
         const unified = unifyMixin(statement, assignments, stated, localContext);
 
         if (unified) {
           return true;
         }
       });
+
+      verified = unified; ///
     }
 
     if (!verified) {
@@ -65,70 +67,41 @@ class Statement {
     return verified;
   }
 
-  unifyWithMetaType(metaType, assignments, stated, localContext) {
-    let unifiedWithMetaType;
-
-    const verifiedGivenMetaType = this.verifyGivenMetaType(metaType, assignments, stated, localContext);
-
-    unifiedWithMetaType = verifiedGivenMetaType;  ///
-
-    return unifiedWithMetaType;
-  }
-
-  verifyAsCombinator(fileContext) {
-    let verifiedAsCombinator;
+  verifyAtTopLevel(fileContext) {
+    let verifiedAtTopLevel;
 
     const statementNode = this.node,  ///
           statementString = this.string;  ///
 
-    fileContext.trace(`Verifying the '${statementString}' statement as a combinator...`);
+    fileContext.trace(`Verifying the '${statementString}' statement at top level...`);
 
-    verifiedAsCombinator = statementAsCombinatorVerifier.verifyStatement(statementNode, fileContext);
+    verifiedAtTopLevel = statementAsCombinatorVerifier.verifyStatement(statementNode, fileContext);
 
-    if (verifiedAsCombinator) {
-      fileContext.debug(`...verified the '${statementString}' statement as a combinator.`, statementNode);
+    if (verifiedAtTopLevel) {
+      fileContext.debug(`...verified the '${statementString}' statement at top level.`, statementNode);
     }
 
-    return verifiedAsCombinator;
+    return verifiedAtTopLevel;
   }
 
   verifyGivenMetaType(metaType, assignments, stated, localContext) {
-    let verifiedGivenMetaType;
+    let verifiedGivenMetaType = false;
+
+    const metaTypeString = metaType.getString(),
+          statementString = this.string;  ///
+
+    localContext.trace(`Verifying the '${statementString}' given the '${metaTypeString}' meta-type...`);
 
     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;
-      }
+    if (metaTypeName === STATEMENT_META_TYPE_NAME) {
+      const verified = this.verify(assignments, stated, localContext)
+
+      verifiedGivenMetaType = verified; ///
+    }
+
+    if (verifiedGivenMetaType) {
+      localContext.debug(`...verified the '${statementString}' given the '${metaTypeString}' meta-type.`);
     }
 
     return verifiedGivenMetaType;
@@ -156,14 +129,9 @@ class Statement {
   }
 
   static fromStatementNode(statementNode, localContext) {
-    let statement;
-
-    if (statementNode !== null) {
-      const node = statementNode, ///
-            string = localContext.nodeAsString(node);
-
-      statement = new Statement(string, node);
-    }
+    const node = statementNode, ///
+          string = localContext.nodeAsString(node),
+          statement = new Statement(string, node);
 
     return statement;
   }

package/src/supposition.js

@@ -1,9 +1,11 @@
 "use strict";
 
 import ProofStep from "./proofStep";
+import LocalContext from "./context/local";
+import metaLevelUnifier from "./unifier/metaLevel";
+import SubproofAssertion from "./assertion/subproof";
 import UnqualifiedStatement from "./statement/unqualified";
 
-import { trim } from "./utilities/string";
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
 
@@ -27,56 +29,86 @@ export default class Supposition {
 
   getStatement() { return this.unqualifiedStatement.getStatement(); }
 
-  // unifyStatement(statementNodeB, substitutions, localContextA, localContextB) {
-  //   let statementUnified = false;
-  //
-  //   if (this.statementNode !== null) {
-  //     const nodeA = this.statementNode,  ///
-  //           nodeB = statementNodeB,  ///
-  //           unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-  //
-  //     statementUnified = unified; ///
-  //   }
-  //
-  //   return statementUnified;
-  // }
-
-  // unifySubproof(subproofNodeB, substitutions, localContextA, localContextB) {
-  //   let subproofUnified = false;
-  //
-  //   if (this.statementNode !== null) {
-  //     const statementNodeA = this.statementNode,
-  //           subproofAssertionNodeA = subproofAssertionNodeQuery(statementNodeA);  ///
-  //
-  //     if (subproofAssertionNodeA !== null) {
-  //       const subproofAssertionStatementNodesA = subproofAssertionStatementNodesQuery(subproofAssertionNodeA),  ///
-  //             subproofSuppositionStatementNodesB = subproofSuppositionStatementNodesQuery(subproofNodeB), ///
-  //             subproofLastProofStepStatementNodeB = subproofLastProofStepStatementNodeQuery(subproofNodeB), ///
-  //             subproofStatementNodesB = [
-  //               ...subproofSuppositionStatementNodesB,
-  //               subproofLastProofStepStatementNodeB
-  //             ];
-  //
-  //       subproofUnified = match(subproofAssertionStatementNodesA, subproofStatementNodesB, (subproofAssertionStatementNodeA, subproofStatementNodeB) => {
-  //         const nodeA = subproofAssertionStatementNodeA,  ///
-  //               nodeB = subproofStatementNodeB, ///
-  //               unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-  //
-  //         if (unified) {
-  //           return true;
-  //         }
-  //       });
-  //     }
-  //   }
-  //
-  //   return subproofUnified;
-  // }
+  unifyProofStep(proofStep, substitutions, localContext) {
+    let proofStepUnified = false;
+
+    const subproof = proofStep.getSubproof(),
+          statement = proofStep.getStatement();
+
+    substitutions.snapshot();
+
+    if (false) {
+      ///
+    } else if (subproof !== null) {
+      proofStepUnified = this.unifySubproof(subproof, substitutions, localContext);
+    } else if (statement !== null) {
+      proofStepUnified = this.unifyStatement(statement, substitutions, localContext);
+    }
+
+    proofStepUnified ?
+      substitutions.continue() :
+        substitutions.rollback(localContext);
+
+    return proofStepUnified;
+  }
+
+  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 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);
+
+    statementUnified = unified; ///
+
+    if (statementUnified) {
+      localContext.debug(`...unified the '${statementString}' statement with the supposition's '${suppositionStatementString}' statement.`);
+    }
+
+    return statementUnified;
+  }
+
+  unifySubproof(subproof, substitutions, localContext) {
+    let subproofUnified = false;
+
+    const supposition = this, ///
+          subproofString = subproof.getString(),
+          suppositionStatement = supposition.getStatement(),
+          suppositionStatementString = suppositionStatement.getString();
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
+
+    const statement = this.unqualifiedStatement.getStatement(),
+          statementNode = statement.getNode(),
+          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, this.fileContext);
+
+    if (subproofAssertion !== null) {
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, localContext);
+    }
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
+    }
+
+    return subproofUnified;
+  }
 
   verify(localContext) {
-    let verified = false,
-        suppositionString = this.getString(); ///
+    let verified = false;
 
-    suppositionString = trim(suppositionString);  ///
+    const suppositionString = this.getString(); ///
 
     if (this.unqualifiedStatement !== null) {
       localContext.trace(`Verifying the '${suppositionString}' supposition...`);
@@ -97,22 +129,43 @@ export default class Supposition {
         }
       }
 
+      if (verified) {
+        localContext.debug(`...verified the '${suppositionString}' supposition.`);
+      }
     } else {
       localContext.debug(`The '${suppositionString}' supposition cannot be verified because it is nonsense.`);
     }
 
-    if (verified) {
-      localContext.debug(`...verified the '${suppositionString}' supposition.`);
-    }
-
     return verified;
   }
 
+  toJSON() {
+    const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
+          unqualifiedStatement = unqualifiedStatementJSON,  ///
+          json = {
+            unqualifiedStatement
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    let { unqualifiedStatement } = json;
+
+    json = unqualifiedStatement;  ///
+
+    unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
+
+    const supposition = new Supposition(fileContext, unqualifiedStatement);
+
+    return supposition;
+  }
+
   static fromSuppositionNode(suppositionNode, fileContext) {
     const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
           supposition = new Supposition(fileContext, unqualifiedStatement);
 
-    return supposition;
+    return supposition
   }
 }

package/src/term.js

@@ -2,6 +2,8 @@
 
 import shim from "./shim";
 import Type from "./type";
+import unifyMixins from "./mixins/term/unify";
+import verifyMixins from "./mixins/term/verify";
 import termAsConstructorVerifier from "./verifier/termAsConstructor";
 
 import { filter } from "./utilities/array";
@@ -29,6 +31,10 @@ class Term {
     return this.type;
   }
 
+  setType(type) {
+    this.type = type;
+  }
+
   match(term) {
     const node = term.getNode(),
           matches = this.node.match(node);
@@ -91,17 +97,38 @@ class Term {
     return implicitlyGrounded;
   }
 
-  verify(fileContext) {
+  verify(localContext, verifyAhead) {
     let verified = false;
 
-    const termString = this.string; ///
+    const term = this, ///
+          termString = this.string;  ///
+
+    localContext.trace(`Verifying the '${termString}' term...`);
+
+    if (!verified) {
+      const unified = unifyMixins.some((unifyMixin) => { ///
+        const unified = unifyMixin(term, localContext, verifyAhead);
+
+        if (unified) {
+          return true;
+        }
+      });
 
-    fileContext.trace(`Verifying the '${termString}' term...`);
+      verified = unified; ///
+    }
+
+    if (!verified) {
+      verified = verifyMixins.some((verifyMixin) => {
+        const verified = verifyMixin(term, localContext, verifyAhead);
 
-    debugger
+        if (verified) {
+          return true;
+        }
+      });
+    }
 
     if (verified) {
-      fileContext.debug(`...verified the '${termString}' type.`);
+      localContext.debug(`...verified the '${termString}' term.`);
     }
 
     return verified;
@@ -135,22 +162,51 @@ class Term {
     return typeVerified;
   }
 
-  verifyAsConstructor(fileContext) {
-    let verifiedAsConstructor;
+  verifyGivenType(type, localContext) {
+    let verifiedGivenType;
+
+    const termString = this.getString(),
+          typeString = type.getString();
+
+    localContext.trace(`Verifying the '${termString}' term given the '${typeString}' type...`);
+
+    const verified = this.verify(localContext, () => {
+      let verifiedAhead;
+
+      const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);
+
+      if (typeEqualToOrSubTypeOfGivenTypeType) {
+        verifiedAhead = true;
+      }
+
+      return verifiedAhead;
+    });
+
+    verifiedGivenType = verified; ///
+
+    if (verifiedGivenType) {
+      localContext.debug(`...verified the '${termString}' term given the '${typeString}' type.`);
+    }
+
+    return verifiedGivenType;
+  }
+
+  verifyAtTopLevel(fileContext) {
+    let verifiedAtTopLevel;
 
     const termString = this.string;  ///
 
-    fileContext.trace(`Verifying the '${termString}' term as a constructor...`);
+    fileContext.trace(`Verifying the '${termString}' term at top level...`);
 
     const termNode = this.node;  ///
 
-    verifiedAsConstructor = termAsConstructorVerifier.verifyTerm(termNode, fileContext);
+    verifiedAtTopLevel = termAsConstructorVerifier.verifyTerm(termNode, fileContext);
 
-    if (verifiedAsConstructor) {
-      fileContext.debug(`...verified the '${termString}' term as a constructor.`, termNode);
+    if (verifiedAtTopLevel) {
+      fileContext.debug(`...verified the '${termString}' term at top level.`, termNode);
     }
 
-    return verifiedAsConstructor;
+    return verifiedAtTopLevel;
   }
 
   toJSON() {
@@ -190,9 +246,9 @@ class Term {
     return term;
   }
 
-  static fromTermNode(termNode, fileContext) {
+  static fromTermNode(termNode, localContext) {
     const node = termNode,  ///
-          string = fileContext.nodeAsString(node),
+          string = localContext.nodeAsString(node),
           type = null,
           term = new Term(string, node, type);