occam-verify-cli 0.0.455 → 0.0.457

package/src/theorem.js

@@ -5,36 +5,31 @@ import Label from "./label";
 import { THEOREM_KIND } from "./kinds";
 import { nodeAsString } from "./utilities/string";
 
-import { statementNodeFromStatementJSON } from "./utilities/node";
+import { unqualifiedStatementNodeFromUnqualifiedStatementString, indicativeConditionalNodeFromIndicativeConditionalString } from "./utilities/string";
 
 export default class Theorem {
-  constructor(labels, statementNode, suppositionStatementNodes, consequentStatementNode) {
+  constructor(labels, unqualifiedStatementNode, indicativeConditionalNode) {
     this.labels = labels;
-    this.statementNode = statementNode;
-    this.suppositionStatementNodes = suppositionStatementNodes;
-    this.consequentStatementNode = consequentStatementNode;
+    this.unqualifiedStatementNode = unqualifiedStatementNode;
+    this.indicativeConditionalNode = indicativeConditionalNode;
   }
 
   getLabels() {
     return this.labels;
   }
 
-  getStatementNode() {
-    return this.statementNode;
+  getUnqualifiedStatementNode() {
+    return this.unqualifiedStatementNode;
   }
 
-  getSuppositionStatementNodes() {
-    return this.suppositionStatementNodes;
-  }
-
-  getConsequentStatementNode() {
-    return this.consequentStatementNode;
+  getIndicativeConditionalNode() {
+    return this.indicativeConditionalNode;
   }
 
   matchLabelName(labelName) {
     const matchesLabelName = this.labels.some((label) => {
       const name = labelName, ///
-            labelMatchesName = label.matchName(name);
+        labelMatchesName = label.matchName(name);
 
       if (labelMatchesName) {
         return true;
@@ -50,24 +45,17 @@ export default class Theorem {
 
             return labelJSON;
           }),
-          statementString = nodeAsString(this.statementNode),
-          consequentStatementString = nodeAsString(this.consequentStatementNode),
-          suppositionStatementStrings = this.suppositionStatementNodes.map((suppositionStatementNode) => {
-            const suppositionStatementString = nodeAsString(suppositionStatementNode);
-
-            return suppositionStatementString;
-          }),
+          unqualifiedStatementString = nodeAsString(this.unqalifiedStatementNode),
+          indicativeConditionalString = nodeAsString(this.indicativeConditionalNode),
           kind = THEOREM_KIND,
           labels = labelsJSON,  ///
-          statement = statementString,  ///
-          consequent = consequentStatementString, ///
-          suppositions = suppositionStatementStrings, ///
+          unqualifiedStatement = unqualifiedStatementString,  ///
+          indicativeConditional = indicativeConditionalString,  ///
           json = {
             kind,
             labels,
-            statement,
-            consequent,
-            suppositions
+            unqualifiedStatement,
+            indicativeConditional
           };
 
     return json;
@@ -79,51 +67,36 @@ export default class Theorem {
     const labelsJSON = labels;  ///
 
     labels = labelsJSON.map((labelJSON) => {
-      const json = labelJSON, ///
-            label = Label.fromJSON(json, releaseContext);
+                const json = labelJSON, ///
+                      label = Label.fromJSON(json, releaseContext);
 
-      return label;
-    });
+                return label;
+              });
 
-    const { statement, suppositions, consequent } = json;
+    let { unqualifiedStatement, indicativeConditional } = json;
 
-    let theorem;
+    let unqualifiedStatementNode = null,
+        indicativeConditionalNode = null;
 
-    if (statement !== null) {
-      const statementJSON = statement,  ///
-            statementNode = statementNodeFromStatementJSON(statementJSON, releaseContext),
-            suppositionStatementNodes = null,
-            consequentStatementNode = null;
+    if (unqualifiedStatement !== null) {
+      const unqualifiedStatementString = unqualifiedStatement;  ///
 
-      theorem = new Theorem(labels, statementNode, suppositionStatementNodes, consequentStatementNode);
-    } else {
-      const statementNode = null,
-            suppositionStatementsJSON = suppositions,  ///
-            suppositionStatementNodes = suppositionStatementsJSON.map((suppositionStatementJSON) => {
-              const suppositionStatementNode = statementNodeFromStatementJSON(suppositionStatementJSON, releaseContext);
+      unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementString(unqualifiedStatementString, releaseContext);
+    }
 
-              return suppositionStatementNode;
-            }),
-            consequentStatementJSON = consequent, ///
-            consequentStatementNode = statementNodeFromStatementJSON(consequentStatementJSON, releaseContext);
+    if (indicativeConditional !== null) {
+      const indicativeConditionalString = indicativeConditional;  ///
 
-      theorem = new Theorem(labels, statementNode, suppositionStatementNodes, consequentStatementNode);
+      indicativeConditionalNode = indicativeConditionalNodeFromIndicativeConditionalString(indicativeConditionalString, releaseContext);
     }
 
-    return theorem;
-  }
-
-  static fromLabelsAndStatementNode(labels, statementNode) {
-    const suppositionStatementNodes = [],
-          consequentStatementNode = null,
-          theorem = new Theorem(labels, statementNode, suppositionStatementNodes, consequentStatementNode);
+    const theorem = new Theorem(labels, unqualifiedStatementNode, indicativeConditionalNode);
 
     return theorem;
   }
 
-  static fromLabelsSuppositionStatementNodesAndConsequentStatementNode(labels, suppositionStatementNodes, consequentStatementNode) {
-    const statementNode = null,
-          theorem = new Theorem(labels, statementNode, suppositionStatementNodes, consequentStatementNode);
+  static fromLabelsUnqualifiedStatementNodeAndIndicativeConditionalNode(labels, unqualifiedStatementNode, indicativeConditionalNode) {
+    const theorem = new Theorem(labels, unqualifiedStatementNode, indicativeConditionalNode);
 
     return theorem;
   }

package/src/utilities/string.js

@@ -1,6 +1,15 @@
 "use strict";
 
 import { COMMA } from "../constants";
+import { nodeQuery } from "../utilities/query";
+import { TERM_RULE_NAME,
+         LABEL_RULE_NAME,
+         UNQUALIFIED_STATEMENT_RULE_NAME,
+         INDICATIVE_CONDITIONAL_RULE_NAME,
+         UNQUALIFIED_METASTATEMENT_RULE_NAME} from "../ruleNames";
+
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement"),
+      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement");
 
 export function nodeAsString(node) {
   let string = null;
@@ -45,3 +54,61 @@ export function nodesAsString(nodes) {
 
   return string;
 }
+
+export function termNodeFromTermString(termString, releaseContext) {
+  const ruleName = TERM_RULE_NAME,
+        content = termString, ///
+        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
+        termNode = node;  ///
+
+  return termNode;
+}
+
+export function labelNodeFromLabelString(labelString, releaseContext) {
+  const content = labelString, ///
+        ruleName = LABEL_RULE_NAME,
+        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
+        labelNode = node; ///
+
+  return labelNode;
+}
+
+export function statementNodeFromStatementString(statementString, releaseContext) {
+  const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
+        content = `${statementString}
+`,
+        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
+        unqualifiedStatementNode = node,  ///
+        statementNode = statementNodeQuery(unqualifiedStatementNode);
+
+  return statementNode;
+}
+
+export function metastatementNodeFromMetastatementString(metastatementString, releaseContext) {
+  const ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
+        content = `${metastatementString}
+`,
+        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
+        unqualifiedMetastatementNode = node,  ///
+        metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+
+  return metastatementNode;
+}
+
+export function unqualifiedStatementNodeFromUnqualifiedStatementString(unqualifiedStatementString, releaseContext) {
+  const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
+        content = unqualifiedStatementString, ///
+        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
+        unqualifiedStatementNode = node;  ///
+
+  return unqualifiedStatementNode;
+}
+
+export function indicativeConditionalNodeFromIndicativeConditionalString(indicativeConditionalString, releaseContext) {
+  const ruleName = INDICATIVE_CONDITIONAL_RULE_NAME,
+        content = indicativeConditionalString, ///
+        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
+        indicativeConditionalNode = node;  ///
+
+  return indicativeConditionalNode;
+}

package/src/verify/assertion/type.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import Variable from "../../variable";
-
 import { first } from "../../utilities/array";
 import { nodeAsString } from "../../utilities/string";
 import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
@@ -10,11 +8,15 @@ import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verif
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type");
 
-export default function verifyTypeAssertion(typeAssertionNode, types, variables, proofContext) {
+export default function verifyTypeAssertion(typeAssertionNode, proofContext) {
   let typeAssertionVerified = false;
 
   proofContext.begin(typeAssertionNode);
 
+  const typeAssertionString = nodeAsString(typeAssertionNode);
+
+  proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`);
+
   const typeNode = typeNodeQuery(typeAssertionNode),
         typeName = typeNameFromTypeNode(typeNode),
         typePresent = proofContext.isTypePresentByTypeName(typeName);
@@ -22,76 +24,50 @@ export default function verifyTypeAssertion(typeAssertionNode, types, variables,
   if (!typePresent) {
     proofContext.error(`The ${typeName} type is not present.`);
   } else {
+    let assertedType = null;
+
     const type = proofContext.findTypeByTypeName(typeName),
           context = proofContext, ///
-          termNode = termNodeQuery(typeAssertionNode),
-          variables = [],
-          termString = nodeAsString(termNode),
+          termNode = termNodeQuery(typeAssertionNode);
+
+    const variables = [],
           termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
 
     if (termVerifiedAsVariable) {
-      types.add(type);
+      const firstVariable = first(variables),
+            variable = firstVariable, ///
+            variableType = variable.getType();
 
-      typeAssertionVerified = true;
+      assertedType = variableType;  ///
     } else {
-      const termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, values, context);
-
-    }
-
+      const types = [],
+            termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
 
-    const ;
+      if (termVerifiedAgainstConstructors) {
+        const firstType = first(types),
+              termType = firstType; ///
 
+        assertedType = termType;  ///
+      }
+    }
 
-    const derived = proofContext.isDerived();
+    if (assertedType !== null) {
+      const typeEqualToOrSubTypeOfAssertedType = type.isEqualToOrSubTypeOf(assertedType);
 
-    if (derived) {
-      debugger
-    } else {
+      if (!typeEqualToOrSubTypeOfAssertedType) {
+        const termString = nodeAsString(termNode);
 
-      if (termVerifiedAsVariable) {
-        const firstVariable = first(variables),
-              variable = firstVariable, ///
-              variableName = variable.getName(),
-              variableDefined = variable.isDefined();
-
-        if (value !== undefined) {
-          proofContext.error(`The value of the ${variableName} variable is not undefined.`);
-        } else {
-          const type = proofContext.findTypeByTypeName(typeName),
-                firstType = first(types),
-                variableType = firstType, ///
-                typeEqualToOrSubTypeOfVariableType = type.isEqualToOrSubTypeOf(variableType);
-
-          if (!typeEqualToOrSubTypeOfVariableType) {
-            proofContext.error(`The asserted type of the ${variableName} variable is not equal to or a sub-type of its declared type.`);
-          } else {
-            const name = variableName,  ///
-                  variable = Variable.fromTypeAndName(type, name);
-
-            proofContext.addVariable(variable);
-
-            typeAssertionVerified = true;
-          }
-        }
+        proofContext.error(`The type of the '${termString}' term or variable is not equal to or a sub-type of the asserted type.`);
       } else {
-
-        if (termVerifiedAgainstConstructors) {
-          const type = proofContext.findTypeByTypeName(typeName),
-                firstType = first(types),
-                termType = firstType, ///
-                typeEqualToOrSubTypeOfTermType = type.isEqualToOrSubTypeOf(termType);
-
-          if (!typeEqualToOrSubTypeOfTermType) {
-            proofContext.error(`The asserted type of the '${termString}' term is not equal to or a sub-type of its declared type.`);
-          } else {
-
-            typeAssertionVerified = true;
-          }
-        }
+        typeAssertionVerified = true;
       }
     }
   }
 
+  if (typeAssertionVerified) {
+    proofContext.info(`Verified the '${typeAssertionString}' type assertion.`);
+  }
+
   typeAssertionVerified ?
     proofContext.complete(typeAssertionNode) :
       proofContext.halt(typeAssertionNode);

package/src/verify/axiom.js

@@ -6,13 +6,10 @@ import ProofContext from "../context/proof";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 import verifyIndicativeConditional from "../verify/indicativeConditional";
 
-import { front, last } from "../utilities/array";
 import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const labelNodesQuery = nodesQuery("/axiom/label"),
-      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      statementNodesQuery = nodesQuery("/indicativeConditional/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/axiom/unqualifiedStatement!"),
       indicativeConditionalNodeQuery = nodeQuery("/axiom/indicativeConditional!");
 
@@ -34,34 +31,23 @@ export default function verifyAxiom(axiomNode, fileContext) {
     const unqualifiedStatementNode = unqualifiedStatementNodeQuery(axiomNode),
           indicativeConditionalNode = indicativeConditionalNodeQuery(axiomNode);
 
-    if (unqualifiedStatementNode !== null) {
-      const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
-
-      if (unqualifiedStatementVerified) {
-        const statementNode = statementNodeQuery(unqualifiedStatementNode),
-              axiom = Axiom.fromLabelsAndStatementNode(labels, statementNode);
-
-        fileContext.addAxiom(axiom);
+    let unqualifiedStatementVerified = false,
+        indicativeConditionalVerified = false;
 
-        axiomVerified = true;
-      }
+    if (unqualifiedStatementNode !== null) {
+      unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
     }
 
     if (indicativeConditionalNode !== null) {
-      const indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, proofContext);
+      indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, proofContext);
+    }
 
-      if (indicativeConditionalVerified) {
-        const statementNodes = statementNodesQuery(indicativeConditionalNode),
-              lastStatementNode = last(statementNodes),
-              frontStatementNodes = front(statementNodes),
-              consequentStatementNode = lastStatementNode,  ///
-              suppositionStatementNodes = frontStatementNodes,  ///
-              axiom = Axiom.fromLabelsSuppositionStatementNodesAndConsequentStatementNode(labels, suppositionStatementNodes, consequentStatementNode);
+    if (unqualifiedStatementVerified || indicativeConditionalVerified) {
+      const axiom = Axiom.fromLabelsUnqualifiedStatementNodeAndIndicativeConditionalNode(labels, unqualifiedStatementNode, indicativeConditionalNode);
 
-        fileContext.addAxiom(axiom);
+      fileContext.addAxiom(axiom);
 
-        axiomVerified = true;
-      }
+      axiomVerified = true;
     }
   }
 

package/src/verify/equality.js

@@ -3,6 +3,7 @@
 import verifyTerm from "../verify/term";
 
 import { nodeQuery } from "../utilities/query";
+import { nodeAsString } from "../utilities/string";
 import { first, second } from "../utilities/array";
 
 const firstTermNodeQuery = nodeQuery("/equality/term[0]"),
@@ -13,6 +14,10 @@ export default function verifyEquality(equalityNode, proofContext) {
 
   proofContext.begin(equalityNode);
 
+  const equalityString = nodeAsString(equalityNode);
+
+  proofContext.debug(`Verifying the '${equalityString}' equality...`);
+
   const types = [],
         context = proofContext,
         firstTermNode = firstTermNodeQuery(equalityNode),
@@ -30,6 +35,10 @@ export default function verifyEquality(equalityNode, proofContext) {
     }
   }
 
+  if (equalityVerified) {
+    proofContext.info(`Verified the '${equalityString}' equality.`);
+  }
+
   equalityVerified ?
     proofContext.complete(equalityNode) :
       proofContext.halt(equalityNode);

package/src/verify/lemma.js

@@ -6,13 +6,10 @@ import ProofContext from "../context/proof";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 import verifyIndicativeConditional from "../verify/indicativeConditional";
 
-import { front, last } from "../utilities/array";
 import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const labelNodesQuery = nodesQuery("/lemma/label"),
-      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      statementNodesQuery = nodesQuery("/indicativeConditional/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/lemma/unqualifiedStatement!"),
       indicativeConditionalNodeQuery = nodeQuery("/lemma/indicativeConditional!");
 
@@ -25,57 +22,37 @@ export default function verifyLemma(lemmaNode, fileContext) {
         labelsString = nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
-  (labelsString === null) ?
-    fileContext.debug(`Verifying an anonymous lemma...`) :
-      fileContext.debug(`Verifying the '${labelsString}' lemma...`);
+  fileContext.debug(`Verifying the '${labelsString}' lemma...`);
 
   const labels = [],
-        labelsLength = labels.length,
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
     const unqualifiedStatementNode = unqualifiedStatementNodeQuery(lemmaNode),
           indicativeConditionalNode = indicativeConditionalNodeQuery(lemmaNode);
 
+    let unqualifiedStatementVerified = false,
+        indicativeConditionalVerified = false;
+
     if (unqualifiedStatementNode !== null) {
-      const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+      unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+    }
 
-      if (unqualifiedStatementVerified) {
-        if (labelsLength > 0) {
-          const statementNode = statementNodeQuery(unqualifiedStatementNode),
-                lemma = Lemma.fromLabelsAndStatementNode(labels, statementNode);
+    if (indicativeConditionalNode !== null) {
+      indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, proofContext);
+    }
 
-          fileContext.addLemma(lemma);
-        }
+    if (unqualifiedStatementVerified || indicativeConditionalVerified) {
+      const lemma = Lemma.fromLabelsUnqualifiedStatementNodeAndIndicativeConditionalNode(labels, unqualifiedStatementNode, indicativeConditionalNode);
 
-        lemmaVerified = true;
-      }
-    }
+      fileContext.addLemma(lemma);
 
-    if (indicativeConditionalNode !== null) {
-      const indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, proofContext);
-
-      if (indicativeConditionalVerified !== null) {
-        if (labelsLength) {
-          const statementNodes = statementNodesQuery(indicativeConditionalNode),
-                lastStatementNode = last(statementNodes),
-                frontStatementNodes = front(statementNodes),
-                consequentStatementNode = lastStatementNode,  ///
-                suppositionStatementNodes = frontStatementNodes,  ///
-                lemma = Lemma.fromLabelsSuppositionStatementNodesAndConsequentStatementNode(labels, suppositionStatementNodes, consequentStatementNode);
-
-          fileContext.addLemma(lemma);
-        }
-
-        lemmaVerified = true;
-      }
+      lemmaVerified = true;
     }
   }
 
   if (lemmaVerified) {
-    (labelsString === null) ?
-      fileContext.info(`Verified an anonymous lemma.`) :
-        fileContext.info(`Verified the '${labelsString}' lemma.`);
+    fileContext.info(`Verified the '${labelsString}' lemma.`);
   }
 
   lemmaVerified ?

package/src/verify/metastatement/qualified.js

@@ -11,6 +11,10 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
 
   metaproofContext.begin(qualifiedMetastatementNode);
 
+  const qualifiedMetastatementString = nodeAsString(qualifiedMetastatementNode);
+
+  metaproofContext.debug(`Verifying the '${qualifiedMetastatementString}' qualified metastatement...`);
+
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
@@ -26,9 +30,7 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
   }
 
   if (qualifiedMetastatementVerified) {
-    const metastatementString = nodeAsString(metastatementNode);
-
-    metaproofContext.debug(`Verified the '${metastatementString}' qualified metastatement.`);
+    metaproofContext.info(`Verified the '${qualifiedMetastatementString}' qualified metastatement.`);
   }
 
   qualifiedMetastatementVerified ?

package/src/verify/metastatement/unqualified.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import MetaAssertion from "../../metaAssertion";
+import verifyMetastatement from "../../verify/metastatement";
 
 import { nodeQuery } from "../../utilities/query";
 import { nodeAsString } from "../../utilities/string";
@@ -12,25 +13,31 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
 
   metaproofContext.begin(unqualifiedMetastatementNode);
 
+  const unqualifiedMetastatementString = nodeAsString(unqualifiedMetastatementNode);
+
+  metaproofContext.info(`Verified the '${unqualifiedMetastatementString}' unqualified metastatement.`);
+
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
-    const derived = metaproofContext.isDerived();
+    const metastatementVerified = verifyMetastatement(metastatementNode, metaproofContext);
 
-    if (derived) {
-      const metaAssertion = MetaAssertion.fromMetastatementNode(metastatementNode),
-            metaAssertionMatches = metaproofContext.matchMetaAssertion(metaAssertion);
+    if (metastatementVerified) {
+      const derived = metaproofContext.isDerived();
 
-      unqualifiedMetastatementVerified = metaAssertionMatches;  ///
-    } else {
-      unqualifiedMetastatementVerified = true;
+      if (derived) {
+        const metaAssertion = MetaAssertion.fromMetastatementNode(metastatementNode),
+              metaAssertionMatches = metaproofContext.matchMetaAssertion(metaAssertion);
+
+        unqualifiedMetastatementVerified = metaAssertionMatches;  ///
+      } else {
+        unqualifiedMetastatementVerified = true;
+      }
     }
   }
 
   if (unqualifiedMetastatementVerified) {
-    const metastatementString = nodeAsString(metastatementNode);
-
-    metaproofContext.debug(`Verified the '${metastatementString}' unqualified metastatement.`);
+    metaproofContext.info(`Verified the '${unqualifiedMetastatementString}' unqualified metastatement.`);
   }
 
   unqualifiedMetastatementVerified ?

package/src/verify/metastatement.js

@@ -0,0 +1,15 @@
+"use strict";
+
+export default function verifyMetastatement(metastatementNode, metaproofContext) {
+  let statementVerified;
+
+  metaproofContext.begin(metastatementNode);
+
+  statementVerified = true; ///
+
+  statementVerified ?
+    metaproofContext.complete(metastatementNode) :
+      metaproofContext.halt(metastatementNode);
+
+  return statementVerified;
+}

package/src/verify/statement/qualified.js

@@ -1,20 +1,32 @@
 "use strict";
 
-import verifyStatement from "../../verify/statement";
+import { nodeAsString } from "../../utilities/string";
+import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
-import { nodeQuery } from "../../utilities/query";
-
-const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
+const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
+      statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
 
 export default function verifyQualifiedStatement(qualifiedStatementNode, proofContext) {
-  let qualifiedStatementVerified;
+  let qualifiedStatementVerified = false;
 
   proofContext.begin(qualifiedStatementNode);
 
-  const statementNode = statementNodeQuery(qualifiedStatementNode),
-        statementVerified = verifyStatement(statementNode, proofContext);
+  const qualifiedStatementString = nodeAsString(qualifiedStatementNode);
+
+  proofContext.debug(`Verifying the '${qualifiedStatementString}' qualified statement...`);
+
+  const statementNode = statementNodeQuery(qualifiedStatementNode);
+
+    if (statementNode !== null) {
+    const referenceNode = referenceNodeQuery(qualifiedStatementNode),
+          referenceName = referenceNameFromReferenceNode(referenceNode);
+
+    ///
+  }
 
-  qualifiedStatementVerified = statementVerified; ///
+  if (qualifiedStatementVerified) {
+    proofContext.info(`Verified the '${qualifiedStatementString}' qualified statement.`);
+  }
 
   qualifiedStatementVerified ?
     proofContext.complete(qualifiedStatementNode) :