occam-verify-cli 0.0.1002 → 0.0.1005

package/src/mixins/statement/verify.js

@@ -0,0 +1,274 @@
+"use strict";
+
+import verifyFrame from "../../verify/frame";
+import verifyEquality from "../../verify/equality";
+import verifyJudgement from "../../verify/judgement";
+import verifyDeclaration from "../../verify/declaration";
+import verifyTypeAssertion from "../../verify/assertion/type";
+import metavariableUnifier from "../../unifier/metavariable";
+import verifyDefinedAssertion from "../../verify/assertion/defined";
+import verifySubproofAssertion from "../../verify/assertion/subproof";
+import verifyContainedAssertion from "../../verify/assertion/contained";
+
+import { nodeQuery } from "../../utilities/query";
+import { metavariableNameFromMetavariableNode } from "../../utilities/name";
+
+const frameNodeQuery = nodeQuery("/statement/frame!"),
+      equalityNodeQuery = nodeQuery("/statement/equality!"),
+      judgementNodeQuery = nodeQuery("/statement/judgement!"),
+      declarationNodeQuery = nodeQuery("/statement/declaration!"),
+      metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
+      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
+      subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
+      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
+
+function verifyAsMetavariable(statement, assignments, stated, localContext) {
+  let verifiedAsMetavariable = false;
+
+  const statementNode = statement.getNode(),
+        metavariableNode = metavariableNodeQuery(statementNode);
+
+  if (metavariableNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a metavariable...`);
+
+    const metavariableUnified = unifyMetavariable(metavariableNode, localContext);
+
+    verifiedAsMetavariable = metavariableUnified;  ///
+
+    if (verifiedAsMetavariable) {
+      localContext.debug(`...verified the '${statementString}' statement as a metavariable.`);
+    }
+  }
+
+  return verifiedAsMetavariable;
+}
+
+function verifyAsEquality(statement, assignments, stated, localContext) {
+  let verifiedAsEquality = false;
+
+  const statementNode = statement.getNode(),
+        equalityNode = equalityNodeQuery(statementNode);
+
+  if (equalityNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as an equality...`);
+
+    const equalityVerified = verifyEquality(equalityNode, assignments, stated, localContext);
+
+    verifiedAsEquality = equalityVerified; ///
+
+    if (verifiedAsEquality) {
+      localContext.debug(`...verified the '${statementString}' statement as an equality.`);
+    }
+  }
+
+  return verifiedAsEquality;
+}
+
+function verifyAsFrame(statement, assignments, stated, localContext) {
+  let verifiedAsFrame = false;
+
+  const statementNode = statement.getNode(),
+        frameNode = frameNodeQuery(statementNode);
+
+  if (frameNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a frame...`);
+
+    const frameVerified = verifyFrame(frameNode, assignments, stated, localContext);
+
+    verifiedAsFrame = frameVerified; ///
+
+    if (verifiedAsFrame) {
+      localContext.debug(`...verified the '${statementString}' statement as a frame.`);
+    }
+  }
+
+  return verifiedAsFrame;
+}
+
+function verifyAsJudgement(statement, assignments, stated, localContext) {
+  let verifiedAsJudgement = false;
+
+  const statementNode = statement.getNode(),
+        judgementNode = judgementNodeQuery(statementNode);
+
+  if (judgementNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a judgement...`);
+
+    const judgementVerified = verifyJudgement(judgementNode, assignments, stated, localContext);
+
+    verifiedAsJudgement = judgementVerified;  ///
+
+    if (verifiedAsJudgement) {
+      localContext.debug(`...verified the '${statementString}' statement as a judgement.`);
+    }
+  }
+
+  return verifiedAsJudgement;
+}
+
+function verifyAsDeclaration(statement, assignments, stated, localContext) {
+  let verifiedAsDeclaration = false;
+
+  const statementNode = statement.getNode(),
+        declarationNode = declarationNodeQuery(statementNode);
+
+  if (declarationNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a declaration...`);
+
+    const declarationVerified = verifyDeclaration(declarationNode, assignments, stated, localContext);
+
+    verifiedAsDeclaration = declarationVerified; ///
+
+    if (verifiedAsDeclaration) {
+      localContext.debug(`...verified the '${statementString}' statement as a declaration.`);
+    }
+  }
+
+  return verifiedAsDeclaration;
+}
+
+function verifyAsTypeAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsTypeAssertion = false;
+
+  const statementNode = statement.getNode(),
+        typeAssertionNode = typeAssertionNodeQuery(statementNode);
+
+  if (typeAssertionNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`);
+
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, stated, localContext);
+
+    verifiedAsTypeAssertion = typeAssertionVerified; ///
+
+    if (verifiedAsTypeAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a type assertion.`);
+    }
+  }
+
+  return verifiedAsTypeAssertion;
+}
+
+function verifyAsDefinedAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsDefinedAssertion = false;
+
+  const statementNode = statement.getNode(),
+        definedAssertionNode = definedAssertionNodeQuery(statementNode);
+
+  if (definedAssertionNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`);
+
+    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, assignments, stated, localContext);
+
+    verifiedAsDefinedAssertion = definedAssertionVerified; ///
+
+    if (verifiedAsDefinedAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`);
+    }
+  }
+
+  return verifiedAsDefinedAssertion;
+}
+
+function verifyAsSubproofAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsSubproofAssertion = false;
+
+  const statementNode = statement.getNode(),
+        subproofAssertionNode = subproofAssertionNodeQuery(statementNode);
+
+  if (subproofAssertionNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`);
+
+    const subproofAssertionVerified = verifySubproofAssertion(subproofAssertionNode, assignments, stated, localContext);
+
+    verifiedAsSubproofAssertion = subproofAssertionVerified; ///
+
+    if (verifiedAsSubproofAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a subproof assertion.`);
+    }
+  }
+
+  return verifiedAsSubproofAssertion;
+}
+
+function verifyAsContainedAssertion(statement, assignments, stated, localContext) {
+  let verifiedAsContainedAssertion = false;
+
+  const statementNode = statement.getNode(),
+        containedAssertionNode = containedAssertionNodeQuery(statementNode);
+
+  if (containedAssertionNode !== null) {
+    const statementString = statement.getString();
+
+    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`);
+
+    const containedAssertionVerified = verifyContainedAssertion(containedAssertionNode, assignments, stated, localContext);
+
+    verifiedAsContainedAssertion = containedAssertionVerified; ///
+
+    if (verifiedAsContainedAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`);
+    }
+  }
+
+  return verifiedAsContainedAssertion;
+}
+
+const verifyMixins = [
+  verifyAsMetavariable,
+  verifyAsEquality,
+  verifyAsFrame,
+  verifyAsJudgement,
+  verifyAsDeclaration,
+  verifyAsTypeAssertion,
+  verifyAsDefinedAssertion,
+  verifyAsSubproofAssertion,
+  verifyAsContainedAssertion
+];
+
+export default verifyMixins;
+
+function unifyMetavariable(metavariableNode, localContext) {
+  let metavariableUnified;
+
+  const metavariableString = localContext.nodeAsString(metavariableNode);
+
+  localContext.trace(`Unifying the '${metavariableString}' metavariable...`);
+
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+
+  if (metavariable !== null) {
+    const metavariableNodeA = metavariableNode; ///
+
+    metavariableNode = metavariable.getNode();
+
+    const metavariableNodeB = metavariableNode; ///
+
+    const unified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
+
+    metavariableUnified = unified;  ///
+  }
+
+  if (metavariableUnified) {
+    localContext.debug(`...unified the '${metavariableString}' metavariable.`);
+  }
+
+  return metavariableUnified;
+}

package/src/node/statement/combinator/bracketed.js

@@ -1,9 +1,10 @@
 "use strict";
 
-import bracketedCombinatorStatementTokens from "../../../tokens/combinatorStatement/bracketed";
+import { STATEMENT_META_TYPE_NAME } from "../../../metaTypeNames";
+import { statementNodeFromStatementString } from "../../../utilities/node";
 
-import { statementNodeFromStatementTokens } from "../../../utilities/node";
+export const bracketedCombinatorStatementString = `(${STATEMENT_META_TYPE_NAME})`;
 
-const bracketedCombinatorStatementNode = statementNodeFromStatementTokens(bracketedCombinatorStatementTokens);
+const bracketedCombinatorStatementNode = statementNodeFromStatementString(bracketedCombinatorStatementString)
 
 export default bracketedCombinatorStatementNode;

package/src/ocmbinator/bracketed.js

@@ -1,23 +1,26 @@
 "use strict";
 
+import shim from "../shim";
 import Combinator from "../combinator";
 import bracketedCombinatorStatementNode from "../node/statement/combinator/bracketed";
-import bracketedCombinatorStatementTokens from "../tokens/combinatorStatement/bracketed";
 
-import { nodeAsString } from "../utilities/string";
+import { bracketedCombinatorStatementString } from "../node/statement/combinator/bracketed";
 
-class BracketedCombinator extends Combinator {
+const localContext = {
+  nodeAsString: (node) => {
+    const string = bracketedCombinatorStatementString;  ///
+
+    return string;
+  }
+};
+
+export default class BracketedCombinator extends Combinator {
   static fromNothing() {
-    const node = bracketedCombinatorStatementNode,  ///
-          tokens = bracketedCombinatorStatementTokens, ///
-          string = nodeAsString(node, tokens),
-          statementNode = node, ///
-          bracketedCombinator = new BracketedCombinator(statementNode, string);
+    const { Statement } = shim,
+          statementNode = bracketedCombinatorStatementNode,  ///
+          statement = Statement.fromStatementNode(statementNode, localContext),
+          bracketedCombinator = new BracketedCombinator(statement);
 
     return bracketedCombinator;
   }
 }
-
-const bracketedCombinator = BracketedCombinator.fromNothing();
-
-export default bracketedCombinator;

package/src/premise.js

@@ -1,73 +1,165 @@
 "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 { match } from "./utilities/array";
-import { nodeAsString } from "./utilities/string";
-import { nodeQuery, nodesQuery } from "./utilities/query";
+import { nodeQuery } from "./utilities/query";
+import { assignAssignments } from "./utilities/assignments";
 
-const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
-      subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
-      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
-      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
+const unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement");
 
 export default class Premise {
-  constructor(statementNode) {
-    this.statementNode = statementNode;
+  constructor(fileContext, unqualifiedStatement) {
+    this.fileContext = fileContext;
+    this.unqualifiedStatement = unqualifiedStatement;
   }
 
-  getStatementNode() {
-    return this.statementNode;
+  getFileContext() {
+    return this.fileContext;
   }
 
-  unifyStatement(statementNodeB, substitutions, localContextA, localContextB) {
-    let statementUnified = false;
+  getUnqualifiedStatement() {
+    return this.unqualifiedStatement;
+  }
+
+  getString() { return this.unqualifiedStatement.getString(); }
+
+  getStatement() { return this.unqualifiedStatement.getStatement(); }
 
-    if (this.statementNode !== null) {
-      const nodeA = this.statementNode,  ///
-            nodeB = statementNodeB,  ///
-            unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+  unifyProofStep(proofStep, substitutions, localContext) {
+    let proofStepUnified = false;
 
-      statementUnified = unified; ///
+    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 premise = this, ///
+          statementString = statement.getString(),
+          premiseStatement = premise.getStatement(),
+          premiseStatementString = premiseStatement.getString();
+
+    localContext.trace(`Unifying the '${statementString}' statement with the premise's '${premiseStatementString}' statement...`);
+
+    const statementNode = statement.getNode(),
+          premiseStatementNode = premiseStatement.getNode(),
+          nodeA = premiseStatementNode,  ///
+          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 premise's '${premiseStatementString}' statement.`);
     }
 
     return statementUnified;
   }
 
-  unifySubproof(subproofNodeB, substitutions, localContextA, localContextB) {
+  unifySubproof(subproof, substitutions, localContext) {
     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;
-          }
-        });
-      }
+    const premise = this, ///
+          subproofString = subproof.getString(),
+          premiseStatement = premise.getStatement(),
+          premiseStatementString = premiseStatement.getString();
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' 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 premise's '${premiseStatementString}' statement.`);
     }
 
     return subproofUnified;
   }
 
-  static fromStatementNode(statementNode) {
-    const premise = new Premise(statementNode);
+  verify(localContext) {
+    let verified = false;
+
+    const premiseString = this.getString(); ///
+
+    if (this.unqualifiedStatement !== null) {
+      localContext.trace(`Verifying the '${premiseString}' premise...`);
+
+      const stated = true,
+            assignments = [],
+            unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+
+      if (unqualifiedStatementVerified) {
+        const assignmentsAssigned = assignAssignments(assignments, localContext);
+
+        if (assignmentsAssigned) {
+          const proofStep = ProofStep.fromUnqualifiedStatement(this.unqualifiedStatement);
+
+          localContext.addProofStep(proofStep);
+
+          verified = true;
+        }
+      }
+
+      if (verified) {
+        localContext.debug(`...verified the '${premiseString}' premise.`);
+      }
+    } else {
+      localContext.debug(`The '${premiseString}' premise cannot be verified because it is nonsense.`);
+    }
+
+    return verified;
+  }
+
+  toJSON() {
+    const unqualifiedStatementString = this.unqualifiedStatement.getString(),
+          unqualifiedStatement = unqualifiedStatementString,  ///
+          json = {
+            unqualifiedStatement
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    let premise = null;
 
     return premise;
   }
+
+  static fromPremiseNode(premiseNode, fileContext) {
+    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(premiseNode),
+          unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
+          premise = new Premise(fileContext, unqualifiedStatement);
+
+    return premise
+  }
 }

package/src/proof.js

@@ -0,0 +1,58 @@
+"use strict";
+
+import Derivation from "./derivation";
+import LocalContext from "./context/local";
+
+import { nodeQuery } from "./utilities/query";
+
+const derivationNodeQuery = nodeQuery("/proof/derivation");
+
+export default class Proof {
+  constructor(derivation) {
+    this.derivation = derivation;
+  }
+
+  getDerivation() {
+    return this.derivation;
+  }
+
+  getLastProofStep() { return this.derivation.getLastProofStep(); }
+
+  verify(substitutions, conclusion, localContext) {
+    let verified = false;
+
+    localContext = LocalContext.fromLocalContext(localContext); ///
+
+    const derivationVerified = this.derivation.verify(substitutions, localContext);
+
+    if (derivationVerified) {
+      const lastProofStep = localContext.getLastProofStep();
+
+      if (lastProofStep !== null) {
+        const lastProofStep = this.getLastProofStep(),
+              conclusionStatement = conclusion.getStatement(),
+              lastProofStepStatement = lastProofStep.getStatement(),
+              conclusionStatementEqualToLastProofStepStatement = conclusionStatement.isEqualTo(lastProofStepStatement);
+
+        if (conclusionStatementEqualToLastProofStepStatement) {
+          verified = true;
+        }
+      }
+    }
+
+    return verified;
+  }
+
+  static fromProofNode(proofNode, fileContext) {
+    let proof = null;
+
+    if (proofNode !== null) {
+      const derivationNode = derivationNodeQuery(proofNode),
+            derivation = Derivation.fromDerivationNode(derivationNode, fileContext);
+
+      proof = new Proof(derivation);
+    }
+
+    return proof;
+  }
+}