occam-verify-cli 0.0.525 → 0.0.527

package/src/verify/assertion/type.js

@@ -1,21 +1,21 @@
 "use strict";
 
+import Variable from "../../variable";
 import TypeAssertion from "../../assertion/type";
 
 import { first } from "../../utilities/array";
-import { nodeAsString } from "../../utilities/string";
+import { verifyTermAsVariable } from "../../verify/term";
 import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
-import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verify/term";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type");
 
-export default function verifyTypeAssertion(typeAssertionNode, assertions, proofContext) {
+export default function verifyTypeAssertion(typeAssertionNode, assertions, derived, proofContext) {
   let typeAssertionVerified = false;
 
   proofContext.begin(typeAssertionNode);
 
-  const typeAssertionString = nodeAsString(typeAssertionNode);
+  const typeAssertionString = proofContext.nodeAsString(typeAssertionNode);
 
   proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`);
 
@@ -27,16 +27,16 @@ export default function verifyTypeAssertion(typeAssertionNode, assertions, proof
     proofContext.error(`The ${typeName} type is not present.`);
   } else {
     if (!typeAssertionVerified) {
-      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext);
+      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, proofContext);
 
       typeAssertionVerified = variableTypeAssertionVerified;  ///
     }
 
-    if (!typeAssertionVerified) {
-      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext);
-
-      typeAssertionVerified = termTypeAssertionVerified;  ///
-    }
+    // if (!typeAssertionVerified) {
+    //   const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext);
+    //
+    //   typeAssertionVerified = termTypeAssertionVerified;  ///
+    // }
   }
 
   if (typeAssertionVerified) {
@@ -50,7 +50,7 @@ export default function verifyTypeAssertion(typeAssertionNode, assertions, proof
   return typeAssertionVerified;
 }
 
-function verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext) {
+function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, proofContext) {
   let variableTypeAssertionVerified = false;
 
   const context = proofContext, ///
@@ -59,18 +59,28 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext
         termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
 
   if (termVerifiedAsVariable) {
-    if (assertions === null) {
-      variableTypeAssertionVerified = true;
+    const typeNode = typeNodeQuery(typeAssertionNode),
+          typeName = typeNameFromTypeNode(typeNode),
+          assertedTypeName = typeName,  ///
+          assertedType = proofContext.findTypeByTypeName(assertedTypeName),
+          firstVariable = first(variables),
+          variable = firstVariable, ///
+          variableName = variable.getName(),
+          variableType = variable.getType();
+
+    if (derived) {
+      const variableTypeEqualToOrSubTypeOfAssertedType = variableType.isEqualToOrSubTypeOf(assertedType);
+
+      if (!variableTypeEqualToOrSubTypeOfAssertedType) {
+        const assertedTypeName = assertedType.getName(),
+              variableTypeName = variableType.getName();
+
+        proofContext.error(`The '${variableName}' variable's '${variableTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`);
+      } else {
+        variableTypeAssertionVerified = true;
+      }
     } else {
-      const typeNode = typeNodeQuery(typeAssertionNode),
-            typeName = typeNameFromTypeNode(typeNode),
-            assertedTypeName = typeName,  ///
-            assertedType = proofContext.findTypeByTypeName(assertedTypeName),
-            firstVariable = first(variables),
-            variable = firstVariable, ///
-            variableName = variable.getName(),
-            variableType = variable.getType(),
-            assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
+      const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
 
       if (!assertedTypeEqualToOrSubTypeOfVariableType) {
         const assertedTypeName = assertedType.getName(),
@@ -79,7 +89,9 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext
         proofContext.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`);
       } else {
         const type = assertedType,  ///
-              typeAssertion = TypeAssertion.fromTypeAndVariableName(type, variableName),
+              name = variableName,  ///
+              variable = Variable.fromTypeAndName(type, name),
+              typeAssertion = TypeAssertion.fromVariable(variable),
               assertion = typeAssertion;  ///
 
         assertions.push(assertion);
@@ -92,46 +104,40 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, proofContext
   return variableTypeAssertionVerified;
 }
 
-function verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext) {
-  let termTypeAssertionVerified = false;
-
-  const types = [],
-        context = proofContext, ///
-        termNode = termNodeQuery(typeAssertionNode),
-        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
-
-  if (termVerifiedAgainstConstructors) {
-    if (assertions === null) {
-      termTypeAssertionVerified = true;
-    } else {
-      const typeNode = typeNodeQuery(typeAssertionNode),
-            typeName = typeNameFromTypeNode(typeNode),
-            assertedTypeName = typeName,  ///
-            assertedType = proofContext.findTypeByTypeName(assertedTypeName),
-            firstType = first(types),
-            termType = firstType,
-            termString = nodeAsString(termNode),
-            assertedTypeEqualToTermType = (termType === null) ?
-                                             true : ///
-                                               assertedType.isEqualTo(termType);
-
-      if (!assertedTypeEqualToTermType) {
-        const termTypeName = termType.getName(),
-              assertedTypeName = assertedType.getName();
-
-        proofContext.error(`The '${assertedTypeName}' asserted type is not equal to the '${termString}' term's '${termTypeName}' type.`);
-      } else {
-        const type = assertedType,  ///
-              typeAssertion = TypeAssertion.fromTypeAndTermNode(type, termNode),
-              assertion = typeAssertion;  ///
-
-        assertions.push(assertion);
-
-        termTypeAssertionVerified = true;
-      }
-    }
-  }
-
-  return termTypeAssertionVerified;
-}
+// function verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext) {
+//   let termTypeAssertionVerified = false;
+//
+//   const types = [],
+//         context = proofContext, ///
+//         termNode = termNodeQuery(typeAssertionNode),
+//         termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
+//
+//   if (termVerifiedAgainstConstructors) {
+//     const typeNode = typeNodeQuery(typeAssertionNode),
+//           typeName = typeNameFromTypeNode(typeNode),
+//           assertedTypeName = typeName,  ///
+//           assertedType = proofContext.findTypeByTypeName(assertedTypeName),
+//           firstType = first(types),
+//           termType = firstType,
+//           termString = proofContext.nodeAsString(termNode),
+//           termTypeEqualToOrSubTypeOfAssertedType = termType.isEqualToOrSubTypeOf(assertedType);
+//
+//     if (!termTypeEqualToOrSubTypeOfAssertedType) {
+//       const termTypeName = termType.getName(),
+//             assertedTypeName = assertedType.getName();
+//
+//       proofContext.error(`The '${termString}' term's '${termTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`);
+//     } else {
+//       const type = assertedType,  ///
+//             typeAssertion = TypeAssertion.fromTypeAndTermNode(type, termNode),
+//             assertion = typeAssertion;  ///
+//
+//       assertions.push(assertion);
+//
+//       termTypeAssertionVerified = true;
+//     }
+//   }
+//
+//   return termTypeAssertionVerified;
+// }
 

package/src/verify/axiom.js

@@ -7,7 +7,6 @@ import verifySupposition from "../verify/supposition";
 import verifyConsequence from "../verify/consequence";
 
 import { first } from "../utilities/array";
-import { nodesAsString } from "../utilities/string";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const labelNodesQuery = nodesQuery("/axiom/label"),
@@ -20,7 +19,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
   fileContext.begin(axiomNode);
 
   const labelNodes = labelNodesQuery(axiomNode),
-        labelsString = nodesAsString(labelNodes),
+        labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
   fileContext.debug(`Verifying the '${labelsString}' axiom...`);

package/src/verify/conclusion.js

@@ -4,7 +4,6 @@ import Conclusion from "../conclusion";
 import verifyUnqualifiedMetastatement from "./metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import { nodeAsString } from "../utilities/string";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/conclusion/unqualifiedMetastatement!");
@@ -14,7 +13,7 @@ export default function verifyConclusion(conclusionNode, conclusions, metaproofC
 
   metaproofContext.begin(conclusionNode);
 
-  const conclusionString = nodeAsString(conclusionNode);
+  const conclusionString = metaproofContext.nodeAsString(conclusionNode);
 
   metaproofContext.debug(`Verifying the '${conclusionString}' conclusion...`);
 

package/src/verify/conjecture.js

@@ -0,0 +1,73 @@
+"use strict";
+
+import Conjecture from "../conjecture";
+import verifyProof from "../verify/proof";
+import ProofContext from "../context/proof";
+import verifyLabels from "../verify/labels";
+import verifySupposition from "./supposition";
+import verifyConsequence from "./consequence";
+
+import { first } from "../utilities/array";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const proofNodeQuery = nodeQuery("/conjecture/proof!"),
+      labelNodesQuery = nodesQuery("/conjecture/label"),
+      consequenceNodeQuery = nodeQuery("/conjecture/consequence!"),
+      suppositionsNodeQuery = nodesQuery("/conjecture/supposition");
+
+export default function verifyConjecture(conjectureNode, fileContext) {
+  let conjectureVerified = false;
+
+  fileContext.begin(conjectureNode);
+
+  const labelNodes = labelNodesQuery(conjectureNode),
+        labelsString = fileContext.nodesAsString(labelNodes),
+        proofContext = ProofContext.fromFileContext(fileContext);
+
+  fileContext.debug(`Verifying the '${labelsString}' conjecture...`);
+
+  const labels = [],
+        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+
+  if (labelsVerified) {
+    const suppositions = [],
+          suppositionNodes = suppositionsNodeQuery(conjectureNode),
+          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
+            const suppositionVerified = verifySupposition(suppositionNode, suppositions, proofContext);
+
+            if (suppositionVerified) {
+              return true;
+            }
+          });
+
+    if (suppositionsVerified) {
+      const consequences = [],
+            consequenceNode = consequenceNodeQuery(conjectureNode),
+            consequenceVerified = verifyConsequence(consequenceNode, consequences, proofContext);
+
+      if (consequenceVerified) {
+        const proofNode = proofNodeQuery(conjectureNode),
+              firstConsequence = first(consequences),
+              consequence = firstConsequence; ///
+
+        verifyProof(proofNode, consequence, proofContext);
+
+        const conjecture = Conjecture.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
+
+        fileContext.addConjecture(conjecture);
+
+        conjectureVerified = true;
+      }
+    }
+  }
+
+  if (conjectureVerified) {
+    fileContext.info(`Verified the '${labelsString}' conjecture.`);
+  }
+
+  conjectureVerified ?
+    fileContext.complete(conjectureNode) :
+      fileContext.complete(conjectureNode);
+
+  return conjectureVerified;
+}

package/src/verify/consequence.js

@@ -4,7 +4,6 @@ import Consequence from "../consequence";
 import verifyUnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import { nodeAsString } from "../utilities/string";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/consequence/unqualifiedStatement!");
@@ -14,9 +13,9 @@ export default function verifyConsequence(consequenceNode, consequences, proofCo
 
   proofContext.begin(consequenceNode);
 
-  const consequenceString = nodeAsString(consequenceNode);
+  const consequenceString = proofContext.nodeAsString(consequenceNode);
 
-  proofContext.debug(`Verifying the ${consequenceString} consequence...`);
+  proofContext.debug(`Verifying the '${consequenceString}' consequence...`);
 
   const derived = false,
         assertions = [],

package/src/verify/declaration/topLevel.js

@@ -4,6 +4,7 @@ import verifyRule from "../../verify/rule";
 import verifyAxiom from "../../verify/axiom";
 import verifyLemma from "../../verify/lemma";
 import verifyTheorem from "../../verify/theorem";
+import verifyConjecture from "../../verify/conjecture";
 import verifyTypeDeclaration from "../../verify/declaration/type";
 import verifyVariableDeclaration from "../../verify/declaration/variable";
 import verifyCombinatorDeclaration from "../../verify/declaration/combinator";
@@ -15,6 +16,7 @@ const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
       axiomNodeQuery = nodeQuery("/topLevelDeclaration/axiom!"),
       lemmaNodeQuery = nodeQuery("/topLevelDeclaration/lemma!"),
       theoremNodeQuery = nodeQuery("/topLevelDeclaration/theorem!"),
+      conjectureNodeQuery = nodeQuery("/topLevelDeclaration/conjecture!"),
       typeDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/typeDeclaration!"),
       variableDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/variableDeclaration!"),
       combinatorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/combinatorDeclaration!"),
@@ -30,6 +32,7 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
         axiomNode = axiomNodeQuery(node),
         lemmaNode = lemmaNodeQuery(node),
         theoremNode = theoremNodeQuery(node),
+        conjectureNode = conjectureNodeQuery(node),
         typeDeclarationNode = typeDeclarationNodeQuery(node),
         variableDeclarationNode = variableDeclarationNodeQuery(node),
         combinatorDeclarationNode = combinatorDeclarationNodeQuery(node),
@@ -53,6 +56,10 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
     const theoremVerified = verifyTheorem(theoremNode, fileContext);
 
     topLevelDeclarationVerified = theoremVerified;  ///
+  } else if (conjectureNode !== null) {
+    const conjectureVerified = verifyConjecture(conjectureNode, fileContext);
+
+    topLevelDeclarationVerified = conjectureVerified;  ///
   } else if (typeDeclarationNode !== null) {
     const typeDeclarationVerified = verifyTypeDeclaration(typeDeclarationNode, fileContext);
 

package/src/verify/label.js

@@ -2,7 +2,6 @@
 
 import Label from "../label";
 
-import { nodeAsString } from "../utilities/string";
 import { labelNameFromLabelNode } from "../utilities/query";
 
 export default function verifyLabel(labelNode, labels, fileContext) {
@@ -14,7 +13,7 @@ export default function verifyLabel(labelNode, labels, fileContext) {
         labelPresent = fileContext.isLabelPresentByLabelName(labelName);
 
   if (labelPresent) {
-    const labelString = nodeAsString(labelNode);
+    const labelString = fileContext.nodeAsString(labelNode);
 
     fileContext.error(`The '${labelString}' label is already present.`, labelNode);
   } else {

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!"),
@@ -23,7 +22,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
   fileContext.begin(lemmaNode);
 
   const labelNodes = labelNodesQuery(lemmaNode),
-        labelsString = nodesAsString(labelNodes),
+        labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
   (labelsString === EMPTY_STRING) ?

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!"),
@@ -16,9 +15,9 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
-    const metastatementString = nodeAsString(metastatementNode);
+    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.debug(`Verifying the ${metastatementString} qualified metastatement...`);
+    metaproofContext.debug(`Verifying the '${metastatementString}' qualified metastatement...`);
 
     let ruleMatchesMetastatement = true;
 

package/src/verify/metastatement/unqualified.js

@@ -3,7 +3,6 @@
 import verifyMetastatement from "../metastatement";
 
 import { nodeQuery } from "../../utilities/query";
-import { nodeAsString } from "../../utilities/string";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
@@ -15,9 +14,9 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
-    const metastatementString = nodeAsString(metastatementNode);
+    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.debug(`Verifying the ${metastatementString} unqualified metastatement...`);
+    metaproofContext.debug(`Verifying the '${metastatementString}' unqualified metastatement...`);
 
     let metastatementMatches = true;
 

package/src/verify/premise.js

@@ -5,7 +5,6 @@ import MetaproofStep from "../step/metaproof";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import { nodeAsString } from "../utilities/string";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!");
@@ -15,9 +14,9 @@ export default function verifyPremise(premiseNode, premises, metaproofContext) {
 
   metaproofContext.begin(premiseNode);
 
-  const premiseString = nodeAsString(premiseNode);
+  const premiseString = metaproofContext.nodeAsString(premiseNode);
 
-  metaproofContext.debug(`Verifying the ${premiseString} premise...`);
+  metaproofContext.debug(`Verifying the '${premiseString}' premise...`);
 
   const derived = false,
         assertions = [],

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"),
@@ -22,7 +21,7 @@ export default function verifyRule(ruleNode, fileContext) {
   fileContext.begin(ruleNode);
 
   const labelNodes = labelNodesQuery(ruleNode),
-        labelsString = nodesAsString(labelNodes),
+        labelsString = fileContext.nodesAsString(labelNodes),
         metaProofContext = MetaproofContext.fromFileContext(fileContext);
 
   fileContext.debug(`Verifying the '${labelsString}' rule...`);

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!"),
@@ -16,28 +15,69 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, asserti
   const statementNode = statementNodeQuery(qualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementString = nodeAsString(statementNode);
+    const statementString = proofContext.nodeAsString(statementNode);
 
-    proofContext.debug(`Verifying the ${statementString} qualified statement...`);
-
-    let ruleMatchesStatement = true;
+    proofContext.debug(`Verifying the '${statementString}' qualified statement...`);
 
     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; ///
+        }
+      }
     }
   }
 

package/src/verify/statement/unqualified.js

@@ -3,7 +3,6 @@
 import verifyStatement from "../statement";
 
 import { nodeQuery } from "../../utilities/query";
-import { nodeAsString } from "../../utilities/string";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
@@ -15,9 +14,9 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
   const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementString = nodeAsString(statementNode);
+    const statementString = proofContext.nodeAsString(statementNode);
 
-    proofContext.debug(`Verifying the ${statementString} unqualified statement...`);
+    proofContext.debug(`Verifying the '${statementString}' unqualified statement...`);
 
     let statementMatches = true;