occam-verify-cli 0.0.892 → 0.0.893

package/src/verify/statement/qualified.js

@@ -1,26 +1,29 @@
 "use strict";
 
-import verifyEquality from "../equality";
-import verifyTypeAssertion from "../typeAssertion";
+import verifyStatement from "../../verify/statement";
 
 import { nodeQuery } from "../../utilities/query";
 
-const equalityNodeQuery = nodeQuery("/qualifiedStatement/statement/equality!"),
-      statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
-      typeAssertionNodeQuery = nodeQuery("/qualifiedStatement/statement/typeAssertion!"),
-      referenceMetavariableNodeQuery = nodeQuery("/qualifiedStatement/reference!/metavariable!");
+const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
+      metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference!/metavariable!");
 
-export default function verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, localContext) {
-  let qualifiedStatementVerified = false;
+export default function verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext) {
+  let qualifiedStatementVerified;
 
-  const statementNode = statementNodeQuery(qualifiedStatementNode);
+  const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-  if (statementNode !== null) {
-    const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+  localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
+  const derived = false,
+        statementNode = statementNodeQuery(qualifiedStatementNode),
+        statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
+          const verifiedAhead = true;
 
-    const referenceMetavariableNode = referenceMetavariableNodeQuery(qualifiedStatementNode),
+          return verifiedAhead;
+        });
+
+  if (statementVerified) {
+    const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
           verifyQualifiedStatementFunctions = [
             verifyQualifiedStatementAAgainstRule,
             verifyQualifiedStatementAAgainstAxiom,
@@ -30,212 +33,137 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
           ];
 
     qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
-      const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, referenceMetavariableNode, localContext);
+      const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, metavariableNode, localContext);
 
       if (qualifiedStatementVerified) {
         return true;
       }
     });
+  }
 
-    if (qualifiedStatementVerified) {
-      derived = false;  ///
-
-      const verifyQualifiedStatementFunctions = [
-              verifyQualifiedStatementAsEquality,
-              verifyQualifiedStatementAsTypeAssertion
-            ];
-
-      qualifiedStatementVerified = verifyQualifiedStatementFunctions.every((verifyQualifiedStatementFunction) => { ///
-        const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, assignments, derived, localContext, () => {
-          const verifiedAhead = true;
-
-          return verifiedAhead;
-        });
-
-        if (qualifiedStatementVerified) {
-          return true;
-        }
-      });
-    }
-
-    if (qualifiedStatementVerified) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement.`, qualifiedStatementNode);
-    }
+  if (qualifiedStatementVerified) {
+    localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement.`, qualifiedStatementNode);
   }
 
   return qualifiedStatementVerified;
 }
 
-function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, referenceMetavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, metavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstRule = false;
 
-  const metavariableNode = referenceMetavariableNode,  ///
-        rule = localContext.findRuleByMetavariableNode(metavariableNode);
+  const rule = localContext.findRuleByMetavariableNode(metavariableNode);
 
   if (rule !== null) {
-    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementLocalContext = localContext, ///
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' rule...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule...`, qualifiedStatementNode);
 
-    const ruleMatchesStatement = rule.matchStatement(statementNode, statementLocalContext);
+    const ruleMatchesStatement = rule.matchStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstRule = ruleMatchesStatement;  ///
 
     if (qualifiedStatementVerifiedAgainstRule) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' rule.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule.`, qualifiedStatementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstRule;
 }
 
-function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, referenceMetavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, metavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstAxiom = false;
 
-  const metavariableNode = referenceMetavariableNode,  ///
-        axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
+  const axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
 
   if (axiom !== null) {
-    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementLocalContext = localContext, ///
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' axiom...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom...`, qualifiedStatementNode);
 
-    const axiomMatchesStatement = axiom.matchStatement(statementNode, statementLocalContext);
+    const axiomMatchesStatement = axiom.matchStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstAxiom = axiomMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstAxiom) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' axiom.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom.`, qualifiedStatementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstAxiom;
 }
 
-function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, referenceMetavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, metavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstLemma = false;
 
-  const metavariableNode = referenceMetavariableNode,  ///
-        lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
+  const lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
 
   if (lemma !== null) {
-    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementLocalContext = localContext, ///
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' lemma...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma...`, qualifiedStatementNode);
 
-    const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementLocalContext);
+    const lemmaMatchesStatement = lemma.matchStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstLemma = lemmaMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstLemma) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' lemma.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma.`, qualifiedStatementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstLemma;
 }
 
-function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, referenceMetavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, metavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstTheorem = false;
 
-  const metavariableNode = referenceMetavariableNode,  ///
-        theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
+  const theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
 
   if (theorem !== null) {
-    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementLocalContext = localContext, ///
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' theorem...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem...`, qualifiedStatementNode);
 
-    const theoremMatchesStatement = theorem.matchStatement(statementNode, statementLocalContext);
+    const theoremMatchesStatement = theorem.matchStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstTheorem = theoremMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstTheorem) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' theorem.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem.`, qualifiedStatementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstTheorem;
 }
 
-function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, referenceMetavariableNode, localContext) {
+function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, metavariableNode, localContext) {
   let qualifiedStatementVerifiedAgainstConjecture = false;
 
-  const metavariableNode = referenceMetavariableNode,  ///
-        conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
+  const conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
 
   if (conjecture !== null) {
-    const referenceMetavariableString = localContext.nodeAsString(referenceMetavariableNode),
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementLocalContext = localContext, ///
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' conjecture...`, statementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture...`, qualifiedStatementNode);
 
-    const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementLocalContext);
+    const conjectureMatchesStatement = conjecture.matchStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstConjecture = conjectureMatchesStatement; ///
 
     if (qualifiedStatementVerifiedAgainstConjecture) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceMetavariableString}' conjecture.`, statementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture.`, qualifiedStatementNode);
     }
   }
 
   return qualifiedStatementVerifiedAgainstConjecture;
 }
-
-function verifyQualifiedStatementAsEquality(qualifiedStatementNode, assignments, derived, localContext, verifyAhead) {
-  let statementVerifiedAsEquality = true; ///
-
-  const equalityNode = equalityNodeQuery(qualifiedStatementNode);
-
-  if (equalityNode !== null) {
-    const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement as an equality...`, qualifiedStatementNode);
-
-    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, verifyAhead);
-
-    statementVerifiedAsEquality = equalityVerified; ///
-
-    if (statementVerifiedAsEquality) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement as an equality.`, qualifiedStatementNode);
-    }
-  }
-
-  return statementVerifiedAsEquality;
-}
-
-function verifyQualifiedStatementAsTypeAssertion(qualifiedStatementNode, assignments, derived, localContext, verifyAhead) {
-  let statementVerifiedAsTypeAssertion = true;  ///
-
-  const typeAssertionNode = typeAssertionNodeQuery(qualifiedStatementNode);
-
-  if (typeAssertionNode !== null) {
-    const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement as a type assertion...`, qualifiedStatementNode);
-
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, verifyAhead);
-
-    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
-
-    if (statementVerifiedAsTypeAssertion) {
-      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement as a type assertion.`, qualifiedStatementNode);
-    }
-  }
-
-  return statementVerifiedAsTypeAssertion;
-}

package/src/verify/statement/unqualified.js

@@ -9,32 +9,29 @@ const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
   let unqualifiedStatementVerified = false;
 
-  const statementNode = statementNodeQuery(unqualifiedStatementNode);
+  const statementNode = statementNodeQuery(unqualifiedStatementNode),
+        unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
 
-  if (statementNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
+  localContext.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`, unqualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${statementString}' unqualified statement...`, unqualifiedStatementNode);
+  if (derived) {
+    const statementMatches = localContext.matchStatement(statementNode);
 
-    if (derived) {
-      const statementMatches = localContext.matchStatement(statementNode);
-
-      unqualifiedStatementVerified = statementMatches;  ///
-    }
+    unqualifiedStatementVerified = statementMatches;  ///
+  }
 
-    if (!unqualifiedStatementVerified) {
-      const statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
-              const verifiedAhead = true;
+  if (!unqualifiedStatementVerified) {
+    const statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
+            const verifiedAhead = true;
 
-              return verifiedAhead;
-            });
+            return verifiedAhead;
+          });
 
-      unqualifiedStatementVerified = statementVerified;  ///
-    }
+    unqualifiedStatementVerified = statementVerified;  ///
+  }
 
-    if (unqualifiedStatementVerified) {
-      localContext.debug(`...verified the '${statementString}' unqualified statement.`, unqualifiedStatementNode);
-    }
+  if (unqualifiedStatementVerified) {
+    localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`, unqualifiedStatementNode);
   }
 
   return unqualifiedStatementVerified;

package/src/verify/subDerivation.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import { nodesQuery } from "../utilities/query";
+
+const proofStepNodesQuery = nodesQuery("/subDerivation/proofStep|lastProofStep");
+
+export default function verifySubDerivation(subDerivationNode, localMetaContext) {
+  let subDerivationVerified;
+
+  const proofStepNodes = proofStepNodesQuery(subDerivationNode);
+
+  subDerivationVerified = proofStepNodes.every((proofStepNode) => {
+    const { verifyProofStep } = verifySubDerivation,
+          proofStepVerified = verifyProofStep(proofStepNode, localMetaContext);
+
+    if (proofStepVerified) {
+      return true;
+    }
+  });
+
+  return subDerivationVerified;
+}

package/src/verify/subproof.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import LocalContext from "../context/local";
+import verifySuppositions from "../verify/suppositions";
+import verifySubDerivation from "../verify/subDerivation";
+
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const suppositionNodesQuery = nodesQuery("/subproof/supposition"),
+      subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
+
+export default function verifySubproof(subproofNode, localContext) {
+  let subproofVerified = false;
+
+  localContext = LocalContext.fromLocalContext(localContext); ///
+
+  const suppositions = [],
+        suppositionNodes = suppositionNodesQuery(subproofNode),
+        suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
+
+  if (suppositionsVerified) {
+    const subDerivationNode = subDerivationNodeQuery(subproofNode),
+          subDerivationVerified = verifySubDerivation(subDerivationNode, localContext);
+
+    if (subDerivationVerified) {
+      subproofVerified = true;
+    }
+  }
+
+  return subproofVerified;
+}
+