occam-verify-cli 0.0.526 → 0.0.529

package/src/verify/derivation.js

@@ -17,8 +17,6 @@ const childNodesQuery = nodesQuery("/derivation|subDerivation/*"),
 export default function verifyDerivation(derivationNode, proofContext) {
   let derivationVerified;
 
-  proofContext.begin(derivationNode);
-
   const childNodes = childNodesQuery(derivationNode);
 
   derivationVerified = childNodes.every((childNode) => {
@@ -29,18 +27,12 @@ export default function verifyDerivation(derivationNode, proofContext) {
     }
   });
 
-  derivationVerified ?
-    proofContext.complete(derivationNode) :
-      proofContext.halt(derivationNode);
-
   return derivationVerified;
 }
 
 function verifySubDerivation(subDerivationNode, proofContext) {
   let subDerivationVerified;
 
-  proofContext.begin(subDerivationNode);
-
   const childNodes = childNodesQuery(subDerivationNode);
 
   subDerivationVerified = childNodes.every((childNode) => {
@@ -51,10 +43,6 @@ function verifySubDerivation(subDerivationNode, proofContext) {
     }
   });
 
-  subDerivationVerified ?
-    proofContext.complete(subDerivationNode) :
-      proofContext.halt(subDerivationNode);
-
   return subDerivationVerified;
 }
 

package/src/verify/label.js

@@ -7,8 +7,6 @@ import { labelNameFromLabelNode } from "../utilities/query";
 export default function verifyLabel(labelNode, labels, fileContext) {
   let labelVerified = false;
 
-  fileContext.begin(labelNode);
-
   const labelName = labelNameFromLabelNode(labelNode),
         labelPresent = fileContext.isLabelPresentByLabelName(labelName);
 
@@ -24,9 +22,5 @@ export default function verifyLabel(labelNode, labels, fileContext) {
     labelVerified = true;
   }
 
-  labelVerified ?
-    fileContext.complete(labelNode) :
-      fileContext.halt(labelNode);
-
   return labelVerified;
 }

package/src/verify/lemma.js

@@ -9,7 +9,6 @@ import verifyConsequence from "./consequence";
 
 import { first } from "../utilities/array";
 import { EMPTY_STRING } from "../constants";
-import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/lemma/proof!"),
@@ -20,15 +19,13 @@ const proofNodeQuery = nodeQuery("/lemma/proof!"),
 export default function verifyLemma(lemmaNode, fileContext) {
   let lemmaVerified = false;
 
-  fileContext.begin(lemmaNode);
-
   const labelNodes = labelNodesQuery(lemmaNode),
         labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
   (labelsString === EMPTY_STRING) ?
-    fileContext.debug(`Verifying a lemma...`) :
-      fileContext.debug(`Verifying the '${labelsString}' lemma...`);
+    fileContext.debug(`Verifying a lemma...`, lemmaNode) :
+      fileContext.debug(`Verifying the '${labelsString}' lemma...`, lemmaNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -68,13 +65,9 @@ export default function verifyLemma(lemmaNode, fileContext) {
 
   if (lemmaVerified) {
     (labelsString === EMPTY_STRING) ?
-      fileContext.info(`Verified the lemma.`) :
-        fileContext.info(`Verified the '${labelsString}' lemma.`);
+      fileContext.info(`Verified the lemma.`, lemmaNode) :
+        fileContext.info(`Verified the '${labelsString}' lemma.`, lemmaNode);
   }
 
-  lemmaVerified ?
-    fileContext.complete(lemmaNode) :
-      fileContext.complete(lemmaNode);
-
   return lemmaVerified;
 }

package/src/verify/metastatement/qualified.js

@@ -2,7 +2,6 @@
 
 import verifyMetastatement from "../../verify/metastatement";
 
-import { nodeAsString } from "../../utilities/string";
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
 const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/reference!"),
@@ -11,14 +10,12 @@ const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/ref
 export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, assertions, derived, metaproofContext) {
   let qualifiedMetastatementVerified = false;
 
-  metaproofContext.begin(qualifiedMetastatementNode);
-
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
     const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.debug(`Verifying the '${metastatementString}' qualified metastatement...`);
+    metaproofContext.debug(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
     let ruleMatchesMetastatement = true;
 
@@ -40,9 +37,5 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
     }
   }
 
-  qualifiedMetastatementVerified ?
-    metaproofContext.complete(qualifiedMetastatementNode) :
-      metaproofContext.halt(qualifiedMetastatementNode);
-
   return qualifiedMetastatementVerified;
 }

package/src/verify/metastatement/unqualified.js

@@ -3,21 +3,18 @@
 import verifyMetastatement from "../metastatement";
 
 import { nodeQuery } from "../../utilities/query";
-import { nodeAsString } from "../../utilities/string";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
 export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assertions, derived, metaproofContext) {
   let unqualifiedMetastatementVerified = false;
 
-  metaproofContext.begin(unqualifiedMetastatementNode);
-
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
     const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.debug(`Verifying the '${metastatementString}' unqualified metastatement...`);
+    metaproofContext.debug(`Verifying the '${metastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
 
     let metastatementMatches = true;
 
@@ -32,9 +29,5 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
     }
   }
 
-  unqualifiedMetastatementVerified ?
-    metaproofContext.complete(unqualifiedMetastatementNode) :
-      metaproofContext.halt(unqualifiedMetastatementNode);
-
   return unqualifiedMetastatementVerified;
 }

package/src/verify/metastatement.js

@@ -3,13 +3,7 @@
 export default function verifyMetastatement(metastatementNode, assertions, derived, metaproofContext) {
   let metastatementVerified = true; ///
 
-  metaproofContext.begin(metastatementNode);
-
   ///
 
-  metastatementVerified ?
-    metaproofContext.complete(metastatementNode) :
-      metaproofContext.halt(metastatementNode);
-
   return metastatementVerified;
 }

package/src/verify/premise.js

@@ -12,11 +12,9 @@ const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatemen
 export default function verifyPremise(premiseNode, premises, metaproofContext) {
   let premiseVerified;
 
-  metaproofContext.begin(premiseNode);
-
   const premiseString = metaproofContext.nodeAsString(premiseNode);
 
-  metaproofContext.debug(`Verifying the '${premiseString}' premise...`);
+  metaproofContext.debug(`Verifying the '${premiseString}' premise...`, premiseNode);
 
   const derived = false,
         assertions = [],
@@ -35,9 +33,5 @@ export default function verifyPremise(premiseNode, premises, metaproofContext) {
     premiseVerified = true;
   }
 
-  premiseVerified ?
-    metaproofContext.complete(premiseNode) :
-      metaproofContext.halt(premiseNode);
-
   return premiseVerified;
 }

package/src/verify/proof.js

@@ -1,8 +1,8 @@
 "use strict";
 
+import matcher from "../matcher";
 import verifyDerivation from "../verify/derivation";
 
-import { matcher } from "../matcher";
 import { nodeQuery } from "../utilities/query";
 
 const derivationNodeQuery = nodeQuery("/proof/derivation!");
@@ -10,8 +10,6 @@ const derivationNodeQuery = nodeQuery("/proof/derivation!");
 export default function verifyProof(proofNode, conclusion, proofContext) {
   let proofVerified = false;
 
-  proofContext.begin(proofNode);
-
   const derivationNode = derivationNodeQuery(proofNode),
         derivationVerified = verifyDerivation(derivationNode, proofContext);
 
@@ -27,9 +25,5 @@ export default function verifyProof(proofNode, conclusion, proofContext) {
     proofVerified = nodeMatches;  ///
   }
 
-  proofVerified ?
-    proofContext.complete(proofNode) :
-      proofContext.complete(proofNode);
-
   return proofVerified;
 }

package/src/verify/rule.js

@@ -8,7 +8,6 @@ import MetaproofContext from "../context/metaproof";
 import verifyConclusion from "../verify/conclusion";
 
 import { first } from "../utilities/array";
-import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const labelNodesQuery = nodesQuery("/rule/label"),
@@ -19,13 +18,11 @@ const labelNodesQuery = nodesQuery("/rule/label"),
 export default function verifyRule(ruleNode, fileContext) {
   let ruleVerified = false;
 
-  fileContext.begin(ruleNode);
-
   const labelNodes = labelNodesQuery(ruleNode),
         labelsString = fileContext.nodesAsString(labelNodes),
         metaProofContext = MetaproofContext.fromFileContext(fileContext);
 
-  fileContext.debug(`Verifying the '${labelsString}' rule...`);
+  fileContext.debug(`Verifying the '${labelsString}' rule...`, ruleNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -69,12 +66,8 @@ export default function verifyRule(ruleNode, fileContext) {
   }
 
   if (ruleVerified) {
-    fileContext.info(`Verified the '${labelsString}' rule.`);
+    fileContext.info(`Verified the '${labelsString}' rule.`, ruleNode);
   }
 
-  ruleVerified ?
-    fileContext.complete(ruleNode) :
-      fileContext.complete(ruleNode);
-
   return ruleVerified;
 }

package/src/verify/ruleDerivation.js

@@ -17,8 +17,6 @@ const childNodesQuery = nodesQuery("/ruleDerivation|ruleSubDerivation/*"),
 export default function verifyRuleDerivation(ruleDerivationNode, metaproofContext) {
   let ruleDerivationVerified;
 
-  metaproofContext.begin(ruleDerivationNode);
-
   const childNodes = childNodesQuery(ruleDerivationNode);
 
   ruleDerivationVerified = childNodes.every((childNode) => {
@@ -29,18 +27,12 @@ export default function verifyRuleDerivation(ruleDerivationNode, metaproofContex
     }
   });
 
-  ruleDerivationVerified ?
-    metaproofContext.complete(ruleDerivationNode) :
-      metaproofContext.halt(ruleDerivationNode);
-
   return ruleDerivationVerified;
 }
 
 function verifyRuleSubDerivation(ruleSubDerivationNode, metaproofContext) {
   let ruleSubDerivationVerified;
 
-  metaproofContext.begin(ruleSubDerivationNode);
-
   const childNodes = childNodesQuery(ruleSubDerivationNode);
 
   ruleSubDerivationVerified = childNodes.every((childNode) => {
@@ -51,10 +43,6 @@ function verifyRuleSubDerivation(ruleSubDerivationNode, metaproofContext) {
     }
   });
 
-  ruleSubDerivationVerified ?
-    metaproofContext.complete(ruleSubDerivationNode) :
-      metaproofContext.halt(ruleSubDerivationNode);
-
   return ruleSubDerivationVerified;
 }
 

package/src/verify/ruleProof.js

@@ -1,8 +1,8 @@
 "use strict";
 
+import matcher from "../matcher";
 import verifyRuleDerivation from "../verify/ruleDerivation";
 
-import { matcher } from "../matcher";
 import { nodeQuery } from "../utilities/query";
 
 const ruleDerivationNodeQuery = nodeQuery("/ruleProof/ruleDerivation!");
@@ -10,8 +10,6 @@ const ruleDerivationNodeQuery = nodeQuery("/ruleProof/ruleDerivation!");
 export default function verifyRuleProof(ruleProofNode, conclusion, metaproofContext) {
   let ruleProofVerified = false;
 
-  metaproofContext.begin(ruleProofNode);
-
   const ruleDerivationNode = ruleDerivationNodeQuery(ruleProofNode),
         ruleDerivationVerified = verifyRuleDerivation(ruleDerivationNode, metaproofContext);
 
@@ -27,9 +25,5 @@ export default function verifyRuleProof(ruleProofNode, conclusion, metaproofCont
     ruleProofVerified = nodeMatches;  ///
   }
 
-  ruleProofVerified ?
-    metaproofContext.complete(ruleProofNode) :
-      metaproofContext.complete(ruleProofNode);
-
   return ruleProofVerified;
 }

package/src/verify/statement/qualified.js

@@ -2,7 +2,6 @@
 
 import verifyStatement from "../../verify/statement";
 
-import { nodeAsString } from "../../utilities/string";
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
 const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
@@ -11,39 +10,74 @@ const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/referen
 export default function verifyQualifiedStatement(qualifiedStatementNode, assertions, derived, proofContext) {
   let qualifiedStatementVerified = false;
 
-  proofContext.begin(qualifiedStatementNode);
-
   const statementNode = statementNodeQuery(qualifiedStatementNode);
 
   if (statementNode !== null) {
     const statementString = proofContext.nodeAsString(statementNode);
 
-    proofContext.debug(`Verifying the '${statementString}' qualified statement...`);
-
-    let ruleMatchesStatement = true;
+    proofContext.debug(`Verifying the '${statementString}' qualified statement...`, qualifiedStatementNode);
 
     const referenceNode = referenceNodeQuery(qualifiedStatementNode);
 
-    if (referenceNode !== null) {
-      const referenceName = referenceNameFromReferenceNode(referenceNode),
-            rule = proofContext.findRuleByReferenceName(referenceName);
-
-      if (rule !== null) {
-        ruleMatchesStatement = rule.matchStatement(statementNode, proofContext);
-      }
-    }
-
-    if (ruleMatchesStatement) {
+    if (referenceNode === null) {
       const context = proofContext,
             statementVerified = verifyStatement(statementNode, assertions, derived, context);
 
       qualifiedStatementVerified = statementVerified; ///
+    } else {
+      const referenceName = referenceNameFromReferenceNode(referenceNode);
+
+      if (!qualifiedStatementVerified) {
+        const rule = proofContext.findRuleByReferenceName(referenceName);
+
+        if (rule !== null) {
+          const ruleMatchesStatement = rule.matchStatement(statementNode, proofContext);
+
+          qualifiedStatementVerified = ruleMatchesStatement;  ///
+        }
+      }
+
+      if (!qualifiedStatementVerified) {
+        const axiom = proofContext.findAxiomByReferenceName(referenceName);
+
+        if (axiom !== null) {
+          const axiomMatchesStatement = axiom.matchStatement(statementNode, proofContext);
+
+          qualifiedStatementVerified = axiomMatchesStatement; ///
+        }
+      }
+
+      if (!qualifiedStatementVerified) {
+        const lemma = proofContext.findLemmaByReferenceName(referenceName);
+
+        if (lemma !== null) {
+          const lemmaMatchesStatement = lemma.matchStatement(statementNode, proofContext);
+
+          qualifiedStatementVerified = lemmaMatchesStatement; ///
+        }
+      }
+
+      if (!qualifiedStatementVerified) {
+        const theorem = proofContext.findTheoremByReferenceName(referenceName);
+
+        if (theorem !== null) {
+          const theoremMatchesStatement = theorem.matchStatement(statementNode, proofContext);
+
+          qualifiedStatementVerified = theoremMatchesStatement; ///
+        }
+      }
+
+      if (!qualifiedStatementVerified) {
+        const conjecture = proofContext.findConjectureByReferenceName(referenceName);
+
+        if (conjecture !== null) {
+          const conjectureMatchesStatement = conjecture.matchStatement(statementNode, proofContext);
+
+          qualifiedStatementVerified = conjectureMatchesStatement; ///
+        }
+      }
     }
   }
 
-  qualifiedStatementVerified ?
-    proofContext.complete(qualifiedStatementNode) :
-      proofContext.halt(qualifiedStatementNode);
-
   return qualifiedStatementVerified;
 }

package/src/verify/statement/unqualified.js

@@ -3,21 +3,18 @@
 import verifyStatement from "../statement";
 
 import { nodeQuery } from "../../utilities/query";
-import { nodeAsString } from "../../utilities/string";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
 export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext) {
   let unqualifiedStatementVerified = false;
 
-  proofContext.begin(unqualifiedStatementNode);
-
   const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
   if (statementNode !== null) {
     const statementString = proofContext.nodeAsString(statementNode);
 
-    proofContext.debug(`Verifying the '${statementString}' unqualified statement...`);
+    proofContext.debug(`Verifying the '${statementString}' unqualified statement...`, unqualifiedStatementNode);
 
     let statementMatches = true;
 
@@ -33,9 +30,5 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
     }
   }
 
-  unqualifiedStatementVerified ?
-    proofContext.complete(unqualifiedStatementNode) :
-      proofContext.halt(unqualifiedStatementNode);
-
   return unqualifiedStatementVerified;
 }