occam-verify-cli 0.0.464 → 0.0.466

package/src/theorem.js

@@ -1,103 +1,13 @@
 "use strict";
 
-import Label from "./label";
+import AxiomLemmaTheorem from "./axiomLemmaTheorem";
 
 import { THEOREM_KIND } from "./kinds";
-import { nodeAsString } from "./utilities/string";
 
-import { unqualifiedStatementNodeFromUnqualifiedStatementString, indicativeConditionalNodeFromIndicativeConditionalString } from "./utilities/string";
+export default class Theorem extends AxiomLemmaTheorem {
+  static kind = THEOREM_KIND;
 
-export default class Theorem {
-  constructor(labels, unqualifiedStatementNode, indicativeConditionalNode) {
-    this.labels = labels;
-    this.unqualifiedStatementNode = unqualifiedStatementNode;
-    this.indicativeConditionalNode = indicativeConditionalNode;
-  }
+  static fromJSON(json, releaseContext) { return AxiomLemmaTheorem.fromJSON(Theorem, json); }
 
-  getLabels() {
-    return this.labels;
-  }
-
-  getUnqualifiedStatementNode() {
-    return this.unqualifiedStatementNode;
-  }
-
-  getIndicativeConditionalNode() {
-    return this.indicativeConditionalNode;
-  }
-
-  matchLabelName(labelName) {
-    const matchesLabelName = this.labels.some((label) => {
-      const name = labelName, ///
-        labelMatchesName = label.matchName(name);
-
-      if (labelMatchesName) {
-        return true;
-      }
-    });
-
-    return matchesLabelName;
-  }
-
-  toJSON() {
-    const labelsJSON = this.labels.map((label) => {
-            const labelJSON = label.toJSON();
-
-            return labelJSON;
-          }),
-          unqualifiedStatementString = nodeAsString(this.unqalifiedStatementNode),
-          indicativeConditionalString = nodeAsString(this.indicativeConditionalNode),
-          kind = THEOREM_KIND,
-          labels = labelsJSON,  ///
-          unqualifiedStatement = unqualifiedStatementString,  ///
-          indicativeConditional = indicativeConditionalString,  ///
-          json = {
-            kind,
-            labels,
-            unqualifiedStatement,
-            indicativeConditional
-          };
-
-    return json;
-  }
-
-  static fromJSON(json, releaseContext) {
-    let { labels } = json;
-
-    const labelsJSON = labels;  ///
-
-    labels = labelsJSON.map((labelJSON) => {
-                const json = labelJSON, ///
-                      label = Label.fromJSON(json, releaseContext);
-
-                return label;
-              });
-
-    let { unqualifiedStatement, indicativeConditional } = json;
-
-    let unqualifiedStatementNode = null,
-        indicativeConditionalNode = null;
-
-    if (unqualifiedStatement !== null) {
-      const unqualifiedStatementString = unqualifiedStatement;  ///
-
-      unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementString(unqualifiedStatementString, releaseContext);
-    }
-
-    if (indicativeConditional !== null) {
-      const indicativeConditionalString = indicativeConditional;  ///
-
-      indicativeConditionalNode = indicativeConditionalNodeFromIndicativeConditionalString(indicativeConditionalString, releaseContext);
-    }
-
-    const theorem = new Theorem(labels, unqualifiedStatementNode, indicativeConditionalNode);
-
-    return theorem;
-  }
-
-  static fromLabelsUnqualifiedStatementNodeAndIndicativeConditionalNode(labels, unqualifiedStatementNode, indicativeConditionalNode) {
-    const theorem = new Theorem(labels, unqualifiedStatementNode, indicativeConditionalNode);
-
-    return theorem;
-  }
+  static fromLabelsAntecedentsAndConsequent(labels, antecedents, consequent) { return AxiomLemmaTheorem.fromLabelsAntecedentsAndConsequent(Theorem, labels, antecedents, consequent); }
 }

package/src/utilities/statement.js

@@ -0,0 +1,50 @@
+"use strict";
+
+import { first, second, third } from "../utilities/array";
+import { STATEMENT_RULE_NAME } from "../ruleNames";
+import { LEFT_BRACKET, RIGHT_BRACKET, BRACKETED_STATEMENT_CHILD_NODES_LENGTH } from "../constants";
+
+export function bracketedStatementChildNodeFromChildNodes(childNodes) {
+  let bracketedStatementChildNode = null;
+
+  const childNodesLength = childNodes.length;
+
+  if (childNodesLength === BRACKETED_STATEMENT_CHILD_NODES_LENGTH) {
+    const firstChildNode = first(childNodes),
+          thirdChildNode = third(childNodes),
+          secondChildNode = second(childNodes),
+          firstChildNodeTerminalNode = firstChildNode.isTerminalNode(),
+          thirdChildNodeTerminalNode = thirdChildNode.isTerminalNode(),
+          secondChildNodeNonTerminalNode = secondChildNode.isNonTerminalNode();
+
+    if (firstChildNodeTerminalNode && secondChildNodeNonTerminalNode && thirdChildNodeTerminalNode) {
+      const nonTerminalNode = secondChildNode,  ///
+            firstTerminalNode = firstChildNode, ///
+            secondTerminalNode = thirdChildNode,  ///
+            nonTerminalNodeRuleName = nonTerminalNode.getRuleName(),
+            firstTerminalNodeContent = firstTerminalNode.getContent(),
+            secondTerminalNodeContent = secondTerminalNode.getContent(),
+            firstTerminalNodeContentLeftBracket = (firstTerminalNodeContent === LEFT_BRACKET),
+            secondTerminalNodeContentRightBracket = (secondTerminalNodeContent === RIGHT_BRACKET),
+            nonTerminalNodeRuleNameStatementRuleName = (nonTerminalNodeRuleName === STATEMENT_RULE_NAME);
+
+      if (firstTerminalNodeContentLeftBracket && nonTerminalNodeRuleNameStatementRuleName && secondTerminalNodeContentRightBracket) {
+        bracketedStatementChildNode = nonTerminalNode;  ///
+      }
+    }
+  }
+
+  return bracketedStatementChildNode;
+}
+
+export function matchBracketedStatementChildNode(childNodes, callback) {
+  let bracketedStatementChildNodeMatches = false;
+
+  const bracketedStatementChildNode = bracketedStatementChildNodeFromChildNodes(childNodes);
+
+  if (bracketedStatementChildNode !== null) {
+    bracketedStatementChildNodeMatches = callback(bracketedStatementChildNode);
+  }
+
+  return bracketedStatementChildNodeMatches;
+}

package/src/utilities/string.js

@@ -5,7 +5,7 @@ import { nodeQuery } from "../utilities/query";
 import { TERM_RULE_NAME,
          LABEL_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
-         INDICATIVE_CONDITIONAL_RULE_NAME,
+         CONDITIONAL_INDICATIVE_RULE_NAME,
          UNQUALIFIED_METASTATEMENT_RULE_NAME} from "../ruleNames";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement"),
@@ -104,11 +104,11 @@ export function unqualifiedStatementNodeFromUnqualifiedStatementString(unqualifi
   return unqualifiedStatementNode;
 }
 
-export function indicativeConditionalNodeFromIndicativeConditionalString(indicativeConditionalString, releaseContext) {
-  const ruleName = INDICATIVE_CONDITIONAL_RULE_NAME,
-        content = indicativeConditionalString, ///
+export function conditionalIndicativeNodeFromConditionalIndicativeString(conditionalIndicativeString, releaseContext) {
+  const ruleName = CONDITIONAL_INDICATIVE_RULE_NAME,
+        content = conditionalIndicativeString, ///
         node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
-        indicativeConditionalNode = node;  ///
+        conditionalIndicativeNode = node;  ///
 
-  return indicativeConditionalNode;
+  return conditionalIndicativeNode;
 }

package/src/verify/antecedentOrAntecedents.js

@@ -0,0 +1,40 @@
+"use strict";
+
+import Assertion from "../assertion";
+import Antecedent from "../antecedent";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement"),
+      unqualifiedStatementNodesQuery = nodesQuery("/antecedent|antecedents/unqualifiedStatement");
+
+export default function verifyAntecedentOrAntecedents(antecedentOrAntecedentsNode, antecedents, proofContext) {
+  let antecedentOrAntecedentsVerified;
+
+  proofContext.begin(antecedentOrAntecedentsNode);
+
+  const unqualifiedStatementNodes = unqualifiedStatementNodesQuery(antecedentOrAntecedentsNode);
+
+  antecedentOrAntecedentsVerified = unqualifiedStatementNodes.every((unqualifiedStatementNode) => {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+
+    if (unqualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode),
+            assertion = Assertion.fromUnqualifiedStatementNode(unqualifiedStatementNode),
+            antecedent = Antecedent.fromStatementNode(statementNode);
+
+      antecedents.push(antecedent);
+
+      proofContext.addAssertion(assertion);
+
+      return true;
+    }
+  });
+
+  antecedentOrAntecedentsVerified ?
+    proofContext.complete(antecedentOrAntecedentsNode) :
+      proofContext.halt(antecedentOrAntecedentsNode);
+
+  return antecedentOrAntecedentsVerified;
+}

package/src/verify/axiom.js

@@ -1,17 +1,18 @@
 "use strict";
 
 import Axiom from "../axiom";
-import verifyLabels from "../verify/labels";
 import ProofContext from "../context/proof";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
-import verifyIndicativeConditional from "../verify/indicativeConditional";
+import verifyLabels from "../verify/labels";
+import verifyConditionalIndicative from "../verify/conditinalIndicative";
+import verifyUnconditionalIndicative from "../verify/unconditionalIndicative";
 
+import { first } from "../utilities/array";
 import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const labelNodesQuery = nodesQuery("/axiom/label"),
-      unqualifiedStatementNodeQuery = nodeQuery("/axiom/unqualifiedStatement!"),
-      indicativeConditionalNodeQuery = nodeQuery("/axiom/indicativeConditional!");
+      conditionalIndicativeNodeQuery = nodeQuery("/axiom/conditionalIndicative!"),
+      unconditionalIndicativeNodeQuery = nodeQuery("/axiom/unconditionalIndicative!");
 
 export default function verifyAxiom(axiomNode, fileContext) {
   let axiomVerified = false;
@@ -28,22 +29,26 @@ export default function verifyAxiom(axiomNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(axiomNode),
-          indicativeConditionalNode = indicativeConditionalNodeQuery(axiomNode);
+    const antecedents = [],
+          consequents = [],
+          conditionalIndicativeNode = conditionalIndicativeNodeQuery(axiomNode),
+          unconditionalIndicativeNode = unconditionalIndicativeNodeQuery(axiomNode);
 
-    let unqualifiedStatementVerified = false,
-        indicativeConditionalVerified = false;
+    let conditionalIndicativeVerified = false,
+      unconditionalIndicativeVerified = false;
 
-    if (unqualifiedStatementNode !== null) {
-      unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+    if (conditionalIndicativeNode !== null) {
+      conditionalIndicativeVerified = verifyConditionalIndicative(conditionalIndicativeNode, antecedents, consequents, proofContext);
     }
 
-    if (indicativeConditionalNode !== null) {
-      indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, proofContext);
+    if (unconditionalIndicativeNode !== null) {
+      unconditionalIndicativeVerified = verifyUnconditionalIndicative(unconditionalIndicativeNode, consequents, proofContext);
     }
 
-    if (unqualifiedStatementVerified || indicativeConditionalVerified) {
-      const axiom = Axiom.fromLabelsUnqualifiedStatementNodeAndIndicativeConditionalNode(labels, unqualifiedStatementNode, indicativeConditionalNode);
+    if (conditionalIndicativeVerified || unconditionalIndicativeVerified) {
+      const firstConsequent = first(consequents),
+            consequent = firstConsequent, ///
+            axiom = Axiom.fromLabelsAntecedentsAndConsequent(labels, antecedents, consequent);
 
       fileContext.addAxiom(axiom);
 
@@ -57,7 +62,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
 
   axiomVerified ?
     fileContext.complete(axiomNode) :
-      fileContext.halt(axiomNode);
+      fileContext.complete(axiomNode);
 
   return axiomVerified;
 }

package/src/verify/conditinalIndicative.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import verifyConsequent from "../verify/consequent";
+import verifyAntecedentOrAntecedents from "../verify/antecedentOrAntecedents";
+
+import { nodeQuery } from "../utilities/query";
+
+const consequentNodeQuery = nodeQuery("/conditionalIndicative/consequent!"),
+      antecedentOrAntecedentsNodeQuery = nodeQuery("/conditionalIndicative/antecedent|antecedents!");
+
+export default function verifyConditionalIndicative(conditionalIndicativeNode, antecedents, consequents, proofContext) {
+  let conditionalIndicativeVerified = false;
+
+  proofContext.begin(conditionalIndicativeNode);
+
+  const consequentNode = consequentNodeQuery(conditionalIndicativeNode),
+        antecedentOrAntecedentsNode = antecedentOrAntecedentsNodeQuery(conditionalIndicativeNode),
+        antecedentOrAntecedentsVerified = verifyAntecedentOrAntecedents(antecedentOrAntecedentsNode, antecedents, proofContext);
+
+  if (antecedentOrAntecedentsVerified) {
+    const consequentVerified = verifyConsequent(consequentNode, consequents, proofContext);
+
+    conditionalIndicativeVerified = consequentVerified;  ///
+  }
+
+  conditionalIndicativeVerified ?
+    proofContext.complete(conditionalIndicativeNode) :
+      proofContext.halt(conditionalIndicativeNode);
+
+  return conditionalIndicativeVerified;
+}

package/src/verify/conditionalIndicative.js

@@ -0,0 +1,29 @@
+"use strict";
+
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+
+import { nodesQuery } from "../utilities/query";
+
+const unqualifiedStatementNodesQuery = nodesQuery("/conditionalIndicative/unqualifiedStatement");
+
+export default function verifyConditionalIndicative(conditionalIndicativeNode, proofContext) {
+  let conditionalIndicativeVerified;
+
+  proofContext.begin(conditionalIndicativeNode);
+
+  const unqualifiedStatementNodes = unqualifiedStatementNodesQuery(conditionalIndicativeNode);
+
+  conditionalIndicativeVerified = unqualifiedStatementNodes.every((unqualifiedStatementNode) => {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+
+    if (unqualifiedStatementVerified) {
+      return true;
+    }
+  });
+
+  conditionalIndicativeVerified ?
+    proofContext.complete(conditionalIndicativeNode) :
+      proofContext.halt(conditionalIndicativeNode);
+
+  return conditionalIndicativeVerified;
+}

package/src/verify/consequent.js

@@ -0,0 +1,36 @@
+"use strict";
+
+import Consequent from "../consequent";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+
+import { nodeQuery } from "../utilities/query";
+
+const statementNodeQuery = nodeQuery("/*/statement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/consequent/unqualifiedStatement!");
+
+export default function verifyConsequent(consequentNode, consequents, proofContext) {
+  let consequentVerified = false;
+
+  proofContext.begin(consequentNode);
+
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequentNode);
+
+  if (unqualifiedStatementNode !== null) {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+
+    if (unqualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode),
+            consequent = Consequent.fromStatementNode(statementNode);
+
+      consequents.push(consequent);
+
+      consequentVerified = true;
+    }
+  }
+
+  consequentVerified ?
+    proofContext.complete(consequentNode) :
+      proofContext.halt(consequentNode);
+
+  return consequentVerified;
+}

package/src/verify/derivation.js

@@ -14,7 +14,7 @@ const derivationNodeQuery = nodeQuery("/subproof/derivation|abridgedDerivation!"
 
 export default function verifyDerivation(derivationNode, proofContext) {
   let derivationVerified,
-    derived;
+      derived;
 
   proofContext.begin(derivationNode);
 

package/src/verify/lemma.js

@@ -1,17 +1,21 @@
 "use strict";
 
 import Lemma from "../lemma";
-import verifyLabels from "../verify/labels";
+import verifyProof from "../verify/proof";
 import ProofContext from "../context/proof";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
-import verifyIndicativeConditional from "../verify/indicativeConditional";
+import verifyLabels from "../verify/labels";
+import verifyConditionalIndicative from "../verify/conditinalIndicative";
+import verifyUnconditionalIndicative from "../verify/unconditionalIndicative";
 
+import { first } from "../utilities/array";
+import { EMPTY_STRING } from "../constants";
 import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/lemma/label"),
-      unqualifiedStatementNodeQuery = nodeQuery("/lemma/unqualifiedStatement!"),
-      indicativeConditionalNodeQuery = nodeQuery("/lemma/indicativeConditional!");
+const proofNodeQuery = nodeQuery("/lemma/proof!"),
+      labelNodesQuery = nodesQuery("/lemma/label"),
+      conditionalIndicativeNodeQuery = nodeQuery("/lemma/conditionalIndicative!"),
+      unconditionalIndicativeNodeQuery = nodeQuery("/lemma/unconditionalIndicative!");
 
 export default function verifyLemma(lemmaNode, fileContext) {
   let lemmaVerified = false;
@@ -22,42 +26,55 @@ export default function verifyLemma(lemmaNode, fileContext) {
         labelsString = nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
-  fileContext.debug(`Verifying the '${labelsString}' lemma...`);
+  (labelsString === EMPTY_STRING) ?
+    fileContext.debug(`Verifying a lemma...`) :
+      fileContext.debug(`Verifying the '${labelsString}' lemma...`);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(lemmaNode),
-          indicativeConditionalNode = indicativeConditionalNodeQuery(lemmaNode);
+    const antecedents = [],
+          consequents = [],
+          conditionalIndicativeNode = conditionalIndicativeNodeQuery(lemmaNode),
+          unconditionalIndicativeNode = unconditionalIndicativeNodeQuery(lemmaNode);
 
-    let unqualifiedStatementVerified = false,
-        indicativeConditionalVerified = false;
+    let conditionalIndicativeVerified = false,
+        unconditionalIndicativeVerified = false;
 
-    if (unqualifiedStatementNode !== null) {
-      unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+    if (conditionalIndicativeNode !== null) {
+      conditionalIndicativeVerified = verifyConditionalIndicative(conditionalIndicativeNode, antecedents, consequents, proofContext);
     }
 
-    if (indicativeConditionalNode !== null) {
-      indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, proofContext);
+    if (unconditionalIndicativeNode !== null) {
+      unconditionalIndicativeVerified = verifyUnconditionalIndicative(unconditionalIndicativeNode, consequents, proofContext);
     }
 
-    if (unqualifiedStatementVerified || indicativeConditionalVerified) {
-      const lemma = Lemma.fromLabelsUnqualifiedStatementNodeAndIndicativeConditionalNode(labels, unqualifiedStatementNode, indicativeConditionalNode);
+    if (conditionalIndicativeVerified || unconditionalIndicativeVerified) {
+      const proofNode = proofNodeQuery(lemmaNode),
+            firstConsequent = first(consequents),
+            consequent = firstConsequent, ///
+            proofVerified = verifyProof(proofNode, consequent, proofContext);
+
+      if (proofVerified) {
+        const lemma = Lemma.fromLabelsAntecedentsAndConsequent(labels, antecedents, consequent);
 
-      fileContext.addLemma(lemma);
+        fileContext.addLemma(lemma);
 
-      lemmaVerified = true;
+        lemmaVerified = true;
+      }
     }
   }
 
   if (lemmaVerified) {
-    fileContext.info(`Verified the '${labelsString}' lemma.`);
+    (labelsString === EMPTY_STRING) ?
+      fileContext.info(`Verified the lemma.`) :
+        fileContext.info(`Verified the '${labelsString}' lemma.`);
   }
 
   lemmaVerified ?
     fileContext.complete(lemmaNode) :
-      fileContext.halt(lemmaNode);
+      fileContext.complete(lemmaNode);
 
   return lemmaVerified;
 }

package/src/verify/proof.js

@@ -1,40 +1,58 @@
 "use strict";
 
+import ProofContext from "../context/proof";
 import verifyDerivation from "../verify/derivation";
 import verifyQualifiedStatement from "../verify/statement/qualified";
 
 import { nodeQuery } from "../utilities/query";
 
 const derivationNodeQuery = nodeQuery("/proof/derivation!"),
-      qualifiedStatementNodeQuery = nodeQuery("/proof/qualifiedStatement!"),
-      proofStatementNodeQuery = nodeQuery("/proof/qualifiedStatement/statement!");
+      qualifiedStatementNodeQuery = nodeQuery("/proof/qualifiedStatement!");
 
-export default function verifyProof(proofNode, conclusion, proofContext) {
+export default function verifyProof(proofNode, fileContext) {
   let proofVerified = false;
 
+  const proofContext = ProofContext.fromFileContext(fileContext);
+
   proofContext.begin(proofNode);
 
-  const derivationNode = derivationNodeQuery(proofNode);
+  const derivationNode = derivationNodeQuery(proofNode),
+        qualifiedStatementNode = qualifiedStatementNodeQuery(proofNode);
 
-  let derivationVerified = true;
+  let derivationVerified = false,
+      qualifiedStatementVerified = false;
 
   if (derivationNode !== null) {
     derivationVerified = verifyDerivation(derivationNode, proofContext);
   }
 
-  if (derivationVerified) {
-    const qualifiedStatementNode = qualifiedStatementNodeQuery(proofNode),
-          qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, proofContext);
+  if (qualifiedStatementNode !== null) {
+    let derived;
 
-    if (qualifiedStatementVerified) {
-      const statementNode = conclusion.getStatementNode(),
-            proofStatementNode = proofStatementNodeQuery(proofNode),
-            proofStatementNodeMatches = matchProofStatementNode(proofStatementNode, statementNode);
+    derived = true;
 
-      proofVerified = proofStatementNodeMatches;  ///
-    }
+    proofContext.setDerived(derived);
+
+    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, proofContext);
+
+    derived = false;
+
+    proofContext.setDerived(derived);
   }
 
+  // if (derivationVerified) {
+  //   const qualifiedStatementNode = qualifiedStatementNodeQuery(proofNode),
+  //         qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, proofContext);
+  //
+  //   if (qualifiedStatementVerified) {
+  //     const statementNode = conclusion.getStatementNode(),
+  //           proofStatementNode = proofStatementNodeQuery(proofNode),
+  //           proofStatementNodeMatches = matchProofStatementNode(proofStatementNode, statementNode);
+  //
+  //     proofVerified = proofStatementNodeMatches;  ///
+  //   }
+  // }
+
   proofVerified ?
     proofContext.complete(proofNode) :
       proofContext.complete(proofNode);

package/src/verify/statement/qualified.js

@@ -1,10 +1,12 @@
 "use strict";
 
+import verifyStatement from "../../verify/statement";
+
 import { nodeAsString } from "../../utilities/string";
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
-const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
-      statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
+const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
+      referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!");
 
 export default function verifyQualifiedStatement(qualifiedStatementNode, proofContext) {
   let qualifiedStatementVerified = false;
@@ -17,11 +19,18 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, proofCo
 
   const statementNode = statementNodeQuery(qualifiedStatementNode);
 
-    if (statementNode !== null) {
-    const referenceNode = referenceNodeQuery(qualifiedStatementNode),
-          referenceName = referenceNameFromReferenceNode(referenceNode);
+  if (statementNode !== null) {
+    const referenceNode = referenceNodeQuery(qualifiedStatementNode);
+
+    if (referenceNode === null) {
+      const statementVerified = verifyStatement(statementNode, proofContext);
+
+      qualifiedStatementVerified = statementVerified; ///
+    } else {
+      const referenceName = referenceNameFromReferenceNode(referenceNode);
 
-    ///
+      debugger
+    }
   }
 
   if (qualifiedStatementVerified) {