occam-verify-cli 0.0.678 → 0.0.680

package/src/verifier/{termForVariable.js → nodes/termForVariable.js}

@@ -1,18 +1,18 @@
 "use strict";
 
-import Verifier from "../verifier";
-import verifyTerm from "../verify/term";
-import TermForVariableSubstitution from "../substitution/termForVariable";
+import verifyTerm from "../../verify/term";
+import NodesVerifier from "../../verifier/nodes";
+import TermForVariableSubstitution from "../../substitution/termForVariable";
 
-import { first } from "../utilities/array";
-import { nodeQuery } from "../utilities/query";
-import { TERM_RULE_NAME } from "../ruleNames";
-import { variableNameFromVariableNode } from "../utilities/query";
+import { first } from "../../utilities/array";
+import { nodeQuery } from "../../utilities/query";
+import { TERM_RULE_NAME } from "../../ruleNames";
+import { variableNameFromVariableNode } from "../../utilities/query";
 
 const variableNodeQuery = nodeQuery('/term/variable!');
 
-export default class TermForVariableVerifier extends Verifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB) {
+export default class TermForVariableNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
@@ -25,28 +25,28 @@ export default class TermForVariableVerifier extends Verifier {
       if (nonTerminalNodeARuleNameTermRuleName && nonTerminalNodeBRuleNameTermRuleName) {
         const termNodeA = nonTerminalNodeA,  ///
               termNodeB = nonTerminalNodeB,  ///
-              termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB);
+              termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB, verifyAhead);
 
         if (termNodeVerified) {
           nonTerminalNodeVerified = true;  ///
         } else {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, verifyAhead);
         }
       } else {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, verifyAhead);
       }
     }
 
     return nonTerminalNodeVerified;
   }
 
-  verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB) {
+  verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB, verifyAhead) {
     let termNodeVerified = false;
 
     const variableNodeA = variableNodeQuery(termNodeA);
 
     if (variableNodeA !== null) {
-      const variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB);
+      const variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB, verifyAhead);
 
       termNodeVerified = variableVerified; ///
     }
@@ -54,8 +54,8 @@ export default class TermForVariableVerifier extends Verifier {
     return termNodeVerified;
   }
 
-  verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB) {
-    let variableVerified;
+  verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB, verifyAhead) {
+    let variableVerified = false;
 
     const variableNameA = variableNameFromVariableNode(variableNodeA),
           substitution = substitutions.find((substitution) => {
@@ -70,7 +70,11 @@ export default class TermForVariableVerifier extends Verifier {
       const termNode = termNodeB, ///
             substitutionNodesVerified = substitution.matchTermNode(termNode);
 
-      variableVerified = substitutionNodesVerified;  ///
+      if (substitutionNodesVerified) {
+        const verifiedAhead = verifyAhead();
+
+        variableVerified = verifiedAhead;  ///
+      }
     } else {
       const { createSubstitutions } = this.constructor;
 
@@ -83,23 +87,31 @@ export default class TermForVariableVerifier extends Verifier {
           const types = [],
                 context = proofContextB, ///
                 termNode = termNodeB, ///
-                termVerified = verifyTerm(termNode, types, context);
+                termVerified = verifyTerm(termNode, types, context, () => {
+                  let verifiedAhead = false;
 
-          if (termVerified) {
-            const firstType = first(types),
-                  termType = firstType,
-                  variableType = variable.getType(),
-                  variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
+                  const firstType = first(types),
+                        termType = firstType,
+                        variableType = variable.getType(),
+                        variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
 
-            if (variableTypeEqualToOrSuperTypeOfTermType) {
-              const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNameAndTermNode(variableName, termNode),
-                    substitution = termForVariableSubstitution;  ///
+                  if (variableTypeEqualToOrSuperTypeOfTermType) {
+                    const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNameAndTermNode(variableName, termNode),
+                          substitution = termForVariableSubstitution;  ///
 
-              substitutions.push(substitution);
+                    substitutions.push(substitution);
 
-              variableVerified = true;
-            }
-          }
+                    verifiedAhead = verifyAhead();
+
+                    if (!verifiedAhead) {
+                      substitutions.pop();
+                    }
+                  }
+
+                  return verifiedAhead;
+                });
+
+          variableVerified = termVerified;  ///
         }
       }
     }

package/src/verifier/nodes.js

@@ -0,0 +1,111 @@
+"use strict";
+
+export default class NodesVerifier {
+  verifyNode(nodeA, nodeB, ...remainingArguments) {
+    let nodeVerified = false;
+
+    const nodeATerminalNode = nodeA.isTerminalNode(),
+          nodeBTerminalNode = nodeB.isTerminalNode(),
+          nodeANonTerminalNode = nodeA.isNonTerminalNode(),
+          nodeBNonTerminalNode = nodeB.isNonTerminalNode();
+
+    if (false) {
+      ///
+    } else if (nodeATerminalNode && nodeBTerminalNode) {
+      const terminalNodeA = nodeA,  ///
+            terminalNodeB = nodeB,  ///
+            terminalNodeVerified = this.verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments);
+
+      nodeVerified = terminalNodeVerified;  ///
+    } else if (nodeANonTerminalNode && nodeBNonTerminalNode) {
+      const nonTerminalNodeA = nodeA,  ///
+            nonTerminalNodeB = nodeB, ///
+            nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments);
+
+      nodeVerified = nonTerminalNodeVerified; ///
+    }
+
+    return nodeVerified;
+  }
+
+  verifyChildNodes(childNodesA, childNodesB, ...remainingArguments) {
+    let childNodesVerify = false;
+
+    const childNodesALength = childNodesA.length,
+          childNodesBLength = childNodesB.length;
+
+    if (childNodesALength === childNodesBLength) {
+      const index = 0,
+            childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
+
+      childNodesVerify = childNodesVerifyAhead; ///
+    }
+
+    return childNodesVerify;
+  }
+
+  verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments) {
+    let childNodesVerify;
+
+    const verifyAhead = remainingArguments.pop(), ///
+          childNodesALength = childNodesA.length;
+
+    if (index === childNodesALength) {
+      const verifiedAhead = verifyAhead();
+
+      childNodesVerify = verifiedAhead; ///
+    } else {
+      const childNodeA = childNodesA[index],
+            childNodeB = childNodesB[index],
+            nodeA = childNodeA, ///
+            nodeB = childNodeB, ///
+            nodeVerified = this.verifyNode(nodeA, nodeB, ...remainingArguments, () => {
+              index++;
+
+              remainingArguments.push(verifyAhead); ///
+
+              const childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
+
+              return childNodesVerifyAhead;
+            });
+
+      childNodesVerify = nodeVerified;  ///
+    }
+
+    return childNodesVerify;
+  }
+
+  verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) {
+    let terminalNodeVerified = false;
+
+    const matches = terminalNodeA.match(terminalNodeB);
+
+    if (matches) {
+      const verifyAhead = remainingArguments.pop(),
+            verifiedAhead = verifyAhead();
+
+      terminalNodeVerified = verifiedAhead;  ///
+    }
+
+    return terminalNodeVerified;
+  }
+
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
+    let nonTerminalNodeVerified = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
+
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+            childNodesA = nonTerminalNodeAChildNodes, ///
+            childNodesB = nonTerminalNodeBChildNodes, ///
+            childNodesVerify = this.verifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
+
+      nonTerminalNodeVerified = childNodesVerify; ///
+    }
+
+    return nonTerminalNodeVerified;
+  }
+}

package/src/verify/axiom.js

@@ -20,7 +20,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
         labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
-  fileContext.debug(`Verifying the '${labelsString}' axiom...`, axiomNode);
+  fileContext.trace(`Verifying the '${labelsString}' axiom...`, axiomNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -54,7 +54,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
   }
 
   if (axiomVerified) {
-    fileContext.info(`Verified the '${labelsString}' axiom.`, axiomNode);
+    fileContext.debug(`...verified the '${labelsString}' axiom.`, axiomNode);
   }
 
   return axiomVerified;

package/src/verify/conclusion.js

@@ -13,7 +13,7 @@ export default function verifyConclusion(conclusionNode, conclusions, metaproofC
 
   const conclusionString = metaproofContext.nodeAsString(conclusionNode);
 
-  metaproofContext.debug(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
+  metaproofContext.trace(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
 
   const derived = false,
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode),
@@ -29,7 +29,7 @@ export default function verifyConclusion(conclusionNode, conclusions, metaproofC
   }
 
   if (conclusionVerified) {
-    metaproofContext.info(`Verified the '${conclusionString}' conclusion.`, conclusionNode);
+    metaproofContext.debug(`...verified the '${conclusionString}' conclusion.`, conclusionNode);
   }
 
   return conclusionVerified;

package/src/verify/conjecture.js

@@ -22,7 +22,7 @@ export default function verifyConjecture(conjectureNode, fileContext) {
         labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
-  fileContext.debug(`Verifying the '${labelsString}' conjecture...`, conjectureNode);
+  fileContext.trace(`Verifying the '${labelsString}' conjecture...`, conjectureNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -60,7 +60,7 @@ export default function verifyConjecture(conjectureNode, fileContext) {
   }
 
   if (conjectureVerified) {
-    fileContext.info(`Verified the '${labelsString}' conjecture.`, conjectureNode);
+    fileContext.debug(`...verified the '${labelsString}' conjecture.`, conjectureNode);
   }
 
   return conjectureVerified;

package/src/verify/consequent.js

@@ -13,7 +13,7 @@ export default function verifyConsequent(consequentNode, consequents, proofConte
 
   const consequentString = proofContext.nodeAsString(consequentNode);
 
-  proofContext.debug(`Verifying the '${consequentString}' consequent...`, consequentNode);
+  proofContext.trace(`Verifying the '${consequentString}' consequent...`, consequentNode);
 
   const derived = false,
         assignments = [],
@@ -30,7 +30,7 @@ export default function verifyConsequent(consequentNode, consequents, proofConte
   }
 
   if (consequentVerified) {
-    proofContext.info(`Verified the '${consequentString}' consequent.`, consequentNode);
+    proofContext.debug(`...verified the '${consequentString}' consequent.`, consequentNode);
   }
 
   return consequentVerified;

package/src/verify/declaration/combinator.js

@@ -10,9 +10,17 @@ export default function verifyCombinatorDeclaration(combinatorDeclarationNode, f
   let combinatorDeclarationVerified;
 
   const statementNode = statementNodeQuery(combinatorDeclarationNode),
-        statementVerifiedAsCombinator = verifyStatementAsCombinator(statementNode, fileContext);
+        statementString = fileContext.nodeAsString(statementNode);
+
+  fileContext.trace(`Verifying the '${statementString}' combinator declaration...`, combinatorDeclarationNode);
+
+  const statementVerifiedAsCombinator = verifyStatementAsCombinator(statementNode, fileContext);
 
   combinatorDeclarationVerified = statementVerifiedAsCombinator; ///
 
+  if (combinatorDeclarationVerified) {
+    fileContext.debug(`...verified the '${statementString}' combinator declaration.`, combinatorDeclarationNode);
+  }
+
   return combinatorDeclarationVerified;
 }

package/src/verify/declaration/constructor.js

@@ -3,6 +3,7 @@
 import verifyTermAsConstructor from "../../verify/termAsConstructor";
 
 import { nodeQuery } from "../../utilities/query";
+import { EMPTY_STRING } from "../../constants";
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
       typeNodeQuery = nodeQuery("/constructorDeclaration/type");
@@ -12,9 +13,22 @@ export default function verifyConstructorDeclaration(constructorDeclarationNode,
 
   const termNode = termNodeQuery(constructorDeclarationNode),
         typeNode = typeNodeQuery(constructorDeclarationNode),
-        termVerifiedAsConstructor = verifyTermAsConstructor(termNode, typeNode, fileContext);
+        termString = fileContext.nodeAsString(termNode),
+        typeString = fileContext.nodeAsString(typeNode);
+
+  (typeString === EMPTY_STRING) ?
+    fileContext.trace(`Verifying the '${termString}' constructor declaration...`, constructorDeclarationNode) :
+      fileContext.trace(`Verifying the '${termString}:${typeString}' constructor declaration...`, constructorDeclarationNode);
+
+  const termVerifiedAsConstructor = verifyTermAsConstructor(termNode, typeNode, fileContext);
 
   constructorDeclarationVerified = termVerifiedAsConstructor; ///
 
+  if (constructorDeclarationVerified) {
+    (typeString === EMPTY_STRING) ?
+      fileContext.debug(`...verified the '${termString}' constructor declaration.`, constructorDeclarationNode) :
+        fileContext.debug(`...verified the '${termString}:${typeString}' constructor declaration.`, constructorDeclarationNode);
+  }
+
   return constructorDeclarationVerified;
 }

package/src/verify/declaration/metavariable.js

@@ -12,9 +12,17 @@ export default function verifyMetavariableDeclaration(metavariableDeclarationNod
 
   const metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
         metavariableNode = metavariableNodeQuery(metavariableDeclarationNode),
-        metavariableVVerified = verifyMetavariable(metavariableNode, metaTypeNode, fileContext);
+        metavariableString = fileContext.nodeAsString(metaTypeNode);
+
+  fileContext.trace(`Verifying the '${metavariableString}' metavariable declaration...`, metavariableDeclarationNode);
+
+  const metavariableVVerified = verifyMetavariable(metavariableNode, metaTypeNode, fileContext);
 
   metavariableDeclarationVerified = metavariableVVerified;  ///
 
+  if (metavariableDeclarationVerified) {
+    fileContext.debug(`...verified the '${metavariableString}' metavariable declaration.`, metavariableDeclarationNode);
+  }
+
   return metavariableDeclarationVerified;
 }

package/src/verify/declaration/type.js

@@ -3,6 +3,7 @@
 import verifyType from "../../verify/type";
 
 import { nodeQuery } from "../../utilities/query";
+import { EMPTY_STRING } from "../../constants";
 
 const firstTypeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
       secondTypeNodeQuery = nodeQuery("/typeDeclaration/type[1]");
@@ -13,11 +14,23 @@ export default function verifyTypeDeclaration(typeDeclarationNode, fileContext)
   const firstTypeNode = firstTypeNodeQuery(typeDeclarationNode),
         secondTypeNode = secondTypeNodeQuery(typeDeclarationNode),
         typeNode = firstTypeNode, ///
-        superTypeNode = secondTypeNode; ///
+        superTypeNode = secondTypeNode, ///
+        typeString = fileContext.nodeAsString(typeNode),
+        superTypeString = fileContext.nodeAsString(superTypeNode);
+
+  (superTypeString === EMPTY_STRING) ?
+    fileContext.trace(`Verifying the '${typeString}' type declaration...`, typeDeclarationNode) :
+      fileContext.trace(`Verifying the '${typeString}:${superTypeString}' type declaration...`, typeDeclarationNode);
 
   const typeVerified = verifyType(typeNode, superTypeNode, fileContext);
 
   typeDeclarationVerified = typeVerified; ///
 
+  if (typeDeclarationVerified) {
+    (superTypeString === EMPTY_STRING) ?
+      fileContext.trace(`...verified the '${typeString}' type declaration.`, typeDeclarationNode) :
+        fileContext.trace(`...verified the '${typeString}:${superTypeString}' type declaration.`, typeDeclarationNode);
+  }
+
   return typeDeclarationVerified;
 }

package/src/verify/declaration/variable.js

@@ -3,6 +3,7 @@
 import verifyVariable from "../../verify/variable";
 
 import { nodeQuery } from "../../utilities/query";
+import { EMPTY_STRING } from "../../constants";
 
 const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
       variableNodeQuery = nodeQuery("/variableDeclaration/variable");
@@ -12,9 +13,22 @@ export default function verifyVariableDeclaration(variableDeclarationNode, fileC
 
   const typeNode = typeNodeQuery(variableDeclarationNode),
         variableNode = variableNodeQuery(variableDeclarationNode),
-        variableVVerified = verifyVariable(variableNode, typeNode, fileContext);
+        typeString = fileContext.nodeAsString(typeNode),
+        variableString = fileContext.nodeAsString(variableNode);
+
+  (typeString === EMPTY_STRING) ?
+    fileContext.trace(`Verifying the '${variableString}' variable declaration...`, variableDeclarationNode) :
+      fileContext.trace(`Verifying the '${variableString}:${typeString}' variable declaration...`, variableDeclarationNode);
+
+  const variableVVerified = verifyVariable(variableNode, typeNode, fileContext);
 
   variableDeclarationVerified = variableVVerified;  ///
 
+  if (variableDeclarationVerified) {
+    (typeString === EMPTY_STRING) ?
+      fileContext.debug(`...verified the '${variableString}' variable declaration.`, variableDeclarationNode) :
+        fileContext.debug(`...verified the '${variableString}:${typeString}' variable declaration.`, variableDeclarationNode);
+  }
+
   return variableDeclarationVerified;
 }

package/src/verify/file.js

@@ -23,7 +23,7 @@ export default function verifyFile(filePath, releaseContext) {
           errorNodesLength = errorNodes.length;
 
     if (errorNodesLength > 0) {
-      releaseContext.error(`The '${filePath}' file cannot be verified because it contains errors.`);
+      releaseContext.warning(`The '${filePath}' file cannot be verified because it contains errors.`);
     } else {
       const topLevelDeclarationNodes = topLevelDeclarationNodesQuery(node),
             topLevelDeclarationsVerified = topLevelDeclarationNodes.every((topLevelDeclarationNode) => {
@@ -43,7 +43,7 @@ export default function verifyFile(filePath, releaseContext) {
   }
 
   if (fileVerified) {
-    releaseContext.info(`Verified the '${filePath}' file.`);
+    releaseContext.info(`...verified the '${filePath}' file.`);
   }
 
   return fileVerified;

package/src/verify/label.js

@@ -8,12 +8,16 @@ export default function verifyLabel(labelNode, labels, fileContext) {
   let labelVerified = false;
 
   const labelName = labelNameFromLabelNode(labelNode),
-        labelPresent = fileContext.isLabelPresentByLabelName(labelName);
+        labelString = fileContext.nodeAsString(labelNode);
+
+  fileContext.trace(`Verifying the '${labelString}' label...`, labelNode);
+
+  const labelPresent = fileContext.isLabelPresentByLabelName(labelName);
 
   if (labelPresent) {
     const labelString = fileContext.nodeAsString(labelNode);
 
-    fileContext.error(`The '${labelString}' label is already present.`, labelNode);
+    fileContext.debug(`The '${labelString}' label is already present.`, labelNode);
   } else {
     const label = Label.fromLabelNode(labelNode);
 
@@ -22,5 +26,9 @@ export default function verifyLabel(labelNode, labels, fileContext) {
     labelVerified = true;
   }
 
+  if (labelVerified) {
+    fileContext.debug(`...verified the '${labelString}' label.`, labelNode);
+  }
+
   return labelVerified;
 }

package/src/verify/lemma.js

@@ -24,8 +24,8 @@ export default function verifyLemma(lemmaNode, fileContext) {
         proofContext = ProofContext.fromFileContext(fileContext);
 
   (labelsString === EMPTY_STRING) ?
-    fileContext.debug(`Verifying a lemma...`, lemmaNode) :
-      fileContext.debug(`Verifying the '${labelsString}' lemma...`, lemmaNode);
+    fileContext.trace(`Verifying a lemma...`, lemmaNode) :
+      fileContext.trace(`Verifying the '${labelsString}' lemma...`, lemmaNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -65,8 +65,8 @@ export default function verifyLemma(lemmaNode, fileContext) {
 
   if (lemmaVerified) {
     (labelsString === EMPTY_STRING) ?
-      fileContext.info(`Verified the lemma.`, lemmaNode) :
-        fileContext.info(`Verified the '${labelsString}' lemma.`, lemmaNode);
+      fileContext.debug(`...verified the lemma.`, lemmaNode) :
+        fileContext.debug(`...verified the '${labelsString}' lemma.`, lemmaNode);
   }
 
   return lemmaVerified;

package/src/verify/metastatement/qualified.js

@@ -14,7 +14,7 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
     const metastatementString = metaproofContext.nodeAsString(metastatementNode),
           metastatementMetaproofContext = metaproofContext; ///
 
-    metaproofContext.debug(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
+    metaproofContext.trace(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
     const referenceNode = referenceNodeQuery(qualifiedMetastatementNode),
           referenceName = referenceNameFromReferenceNode(referenceNode),
@@ -25,12 +25,10 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
 
       qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
     }
-  }
-
-  if (qualifiedMetastatementVerified) {
-    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.info(`Verified the '${metastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
+    if (qualifiedMetastatementVerified) {
+      metaproofContext.debug(`...verified the '${metastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
+    }
   }
 
   return qualifiedMetastatementVerified;

package/src/verify/metastatement/unqualified.js

@@ -14,7 +14,7 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
   if (metastatementNode !== null) {
     const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.debug(`Verifying the '${metastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
+    metaproofContext.trace(`Verifying the '${metastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
 
     if (derived) {
       const metastatementMatches = metaproofContext.matchMetastatement(metastatementNode);
@@ -23,16 +23,18 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
     }
 
     if (!unqualifiedMetastatementVerified) {
-      const metastatementVerified = verifyMetastatement(metastatementNode, derived, metaproofContext);
+      const metastatementVerified = verifyMetastatement(metastatementNode, derived, metaproofContext, () => {
+        const verifiedAhead = true;
+
+        return verifiedAhead;
+      });
 
       unqualifiedMetastatementVerified = metastatementVerified; ///
     }
-  }
 
-  if (unqualifiedMetastatementVerified) {
-    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
-
-    metaproofContext.info(`Verified the '${metastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
+    if (unqualifiedMetastatementVerified) {
+      metaproofContext.debug(`...verified the '${metastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
+    }
   }
 
   return unqualifiedMetastatementVerified;