occam-verify-cli 0.0.471 → 0.0.472

package/src/metaSubstitution.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { matchBracketedMetastatementChildNode, bracketedMetastatementChildNodeFromChildNodes } from "./utilities/metaAssertion";
+import { matchNodes, bracketedChildNodeFromChildNodes } from "./utilities/node";
 
 export default class MetaSubstitution {
   constructor(metavariableName, nodes) {
@@ -19,34 +19,34 @@ export default class MetaSubstitution {
   matchNodes(nodes) {
     let matches;
 
-    const metaSubstitutionNodes = this.nodes,  ///
-          metaSubstitutionNonTerminalNodeMatches = matchMetaSubstitutionNodes(metaSubstitutionNodes, nodes);
+    const nodesA = this.nodes,  ///
+          nodesB = nodes,
+          metaSubstitutionNodesMatch = matchNodes(nodesA, nodesB);
 
-    matches = metaSubstitutionNonTerminalNodeMatches;  ///
+    matches = metaSubstitutionNodesMatch;  ///
 
     if (!matches) {
       const childNodes = nodes, ///
-            bracketedMetastatementChildNodeMatches = matchBracketedMetastatementChildNode(childNodes, (bracketedMetastatementChildNode) => {
-              const nonTerminalNode = bracketedMetastatementChildNode,  ///
-                    childNodes = nonTerminalNode.getChildNodes(),
-                    nodes = childNodes, ///
-                    metaAssertionNonTerminalNodeMatches = matchMetaSubstitutionNodes(metaSubstitutionNodes, nodes),
-                    bracketedMetastatementChildNodeMatches = metaAssertionNonTerminalNodeMatches; ///
+            bracketedChildNode = bracketedChildNodeFromChildNodes(childNodes);
 
-              return bracketedMetastatementChildNodeMatches;
-            });
+      if (bracketedChildNode !== null) {
+        const nonTerminalNode = bracketedChildNode,  ///
+              childNodes = nonTerminalNode.getChildNodes(),
+              nodesB = childNodes, ///
+              nodesMatch = matchNodes(nodesA, nodesB);
 
-      matches = bracketedMetastatementChildNodeMatches; ///
+        matches = nodesMatch; ///
+      }
     }
 
     return matches;
   }
 
   static fromMetavariableNameAndNodes(metavariableName, nodes) {
-    const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromChildNodes(nodes);
+    const bracketedChildNode = bracketedChildNodeFromChildNodes(nodes);
 
-    if (bracketedMetastatementChildNode !== null) {
-      const nonTerminalNode = bracketedMetastatementChildNode,  ///
+    if (bracketedChildNode !== null) {
+      const nonTerminalNode = bracketedChildNode,  ///
             childNodes = nonTerminalNode.getChildNodes();
 
       nodes = childNodes; ///
@@ -57,74 +57,3 @@ export default class MetaSubstitution {
     return metaSubstitution;
   }
 }
-
-function matchMetaSubstitutionNode(metaSubstitutionNode, node) {
-  let metaSubstitutionNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = metaSubstitutionNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            metaSubstitutionTerminalNode = metaSubstitutionNode,  ///
-            metaSubstitutionTerminalNodeMatches = matchMetaSubstitutionTerminalNode(metaSubstitutionTerminalNode, terminalNode);
-
-      metaSubstitutionNodeMatches = metaSubstitutionTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            metaSubstitutionNonTerminalNode = metaSubstitutionNode,  ///
-            metaSubstitutionNonTerminalNodeMatches = matchMetaSubstitutionNonTerminalNode(metaSubstitutionNonTerminalNode, nonTerminalNode);
-
-      metaSubstitutionNodeMatches = metaSubstitutionNonTerminalNodeMatches; ///
-    }
-  }
-
-  return metaSubstitutionNodeMatches;
-}
-
-function matchMetaSubstitutionNodes(metaSubstitutionNodes, nodes) {
-  let metaSubstitutionNodesMatches = false;
-
-  const nodesLength = nodes.length,
-        metaSubstitutionNodesLength = metaSubstitutionNodes.length;
-
-  if (nodesLength === metaSubstitutionNodesLength) {
-    metaSubstitutionNodesMatches = nodes.every((node, index) => {
-      const metaSubstitutionNode = metaSubstitutionNodes[index],
-            metaSubstitutionNodeMatches = matchMetaSubstitutionNode(metaSubstitutionNode, node);
-
-      if (metaSubstitutionNodeMatches) {
-        return true;
-      }
-    })
-  }
-
-  return metaSubstitutionNodesMatches;
-}
-
-function matchMetaSubstitutionTerminalNode(metaSubstitutionTerminalNode, terminalNode) {
-  const matches = metaSubstitutionTerminalNode.match(terminalNode),
-        metaSubstitutionTerminalNodeMatches = matches;  ///
-
-  return metaSubstitutionTerminalNodeMatches;
-}
-
-function matchMetaSubstitutionNonTerminalNode(metaSubstitutionNonTerminalNode, nonTerminalNode) {
-  let metaSubstitutionNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        metaSubstitutionRuleName = metaSubstitutionNonTerminalNode.getRuleName(); ///
-
-  if (ruleName === metaSubstitutionRuleName) {
-    const childNodes = nonTerminalNode.getChildNodes(),
-          metaSubstitutionChildNodes = metaSubstitutionNonTerminalNode.getChildNodes(),
-          nodes = childNodes, ///
-          metaSubstitutionNodes = metaSubstitutionChildNodes, ///
-          metaSubstitutionNodesMatches = matchMetaSubstitutionNodes(metaSubstitutionNodes, nodes);
-
-    metaSubstitutionNonTerminalNodeMatches = metaSubstitutionNodesMatches; ///
-  }
-
-  return metaSubstitutionNonTerminalNodeMatches;
-}

package/src/step/metaproof.js

@@ -2,8 +2,7 @@
 
 import { first, second } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
-
-import { matchTopmostMetaAssertionMetastatementNode } from "../utilities/metaAssertion";
+import { matchBracketedNonTerminalNode } from "../utilities/node";
 
 const metastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
       metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion"),
@@ -45,10 +44,10 @@ export default class MetaproofStep {
     let metastatementsMatch = false;
 
     if (this.metastatementNode !== null) {
-      const topmostMetastatementNode = metastatementNode, ///
-            topmostMetaAssertionMetastatementNode = this.metastatementNode,  ///
-            topmostMetaAssertionMetastatementNodeMatches = matchTopmostMetaAssertionMetastatementNode(topmostMetaAssertionMetastatementNode, topmostMetastatementNode),
-            metastatementNodeMatches = topmostMetaAssertionMetastatementNodeMatches;  ///
+      const nonTerminalNodeA = metastatementNode, ///
+            nonTerminalNodeB = this.metastatementNode,  ///
+            bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB),
+            metastatementNodeMatches = bracketedNodeMatches;  ///
 
       return metastatementNodeMatches;
     }
@@ -65,19 +64,19 @@ export default class MetaproofStep {
             qualifiedOrUnqualifiedMetastatementMetastatementNodes = qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery(this.metaSubproofNode),
             firstQualifiedOrUnqualifiedMetastatementMetastatementNode = first(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
 
-      const topmostMetastatementNode = firstMetaSubproofAssertionMetastatementNode,  ///
-            topmostMetaAssertionMetastatementNode = firstQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
-            topmostMetaAssertionMetastatementNodeMatches = matchTopmostMetaAssertionMetastatementNode(topmostMetaAssertionMetastatementNode, topmostMetastatementNode);
+      const nonTerminalNodeA = firstMetaSubproofAssertionMetastatementNode,  ///
+            nonTerminalNodeB = firstQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
+            bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
 
-      if (topmostMetaAssertionMetastatementNodeMatches) {
+      if (bracketedNodeMatches) {
         const secondMetaSubproofAssertionMetastatementNode = second(metaSubproofAssertionMetastatementNodes),
               secondQualifiedOrUnqualifiedMetastatementMetastatementNode = second(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
 
-        const topmostMetastatementNode = secondMetaSubproofAssertionMetastatementNode, ///
-              topmostMetaAssertionMetastatementNode = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
-              topmostMetaAssertionMetastatementNodeMatches = matchTopmostMetaAssertionMetastatementNode(topmostMetaAssertionMetastatementNode, topmostMetastatementNode);
+        const nonTerminalNodeA = secondMetaSubproofAssertionMetastatementNode, ///
+              nonTerminalNodeB = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
+              bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
 
-        metaSubproofAssertionMatches = topmostMetaAssertionMetastatementNodeMatches; ///
+        metaSubproofAssertionMatches = bracketedNodeMatches; ///
       }
     }
 

package/src/substitution.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { matchBracketedStatementChildNode, bracketedStatementChildNodeFromChildNodes } from "./utilities/statement";
+import { matchNodes, bracketedChildNodeFromChildNodes } from "./utilities/node";
 
 export default class Substitution {
   constructor(variableName, nodes) {
@@ -19,112 +19,41 @@ export default class Substitution {
   matchNodes(nodes) {
     let matches;
 
-    const substitutionNodes = this.nodes,  ///
-          substitutionNonTerminalNodeMatches = matchSubstitutionNodes(substitutionNodes, nodes);
+    const nodesA = this.nodes,  ///
+          nodesB = nodes,
+          metaSubstitutionNodesMatch = matchNodes(nodesA, nodesB);
 
-    matches = substitutionNonTerminalNodeMatches;  ///
+    matches = metaSubstitutionNodesMatch;  ///
 
     if (!matches) {
       const childNodes = nodes, ///
-            bracketedStatementChildNodeMatches = matchBracketedStatementChildNode(childNodes, (bracketedStatementChildNode) => {
-              const nonTerminalNode = bracketedStatementChildNode,  ///
-                    childNodes = nonTerminalNode.getChildNodes(),
-                    nodes = childNodes, ///
-                    assertionNonTerminalNodeMatches = matchSubstitutionNodes(substitutionNodes, nodes),
-                    bracketedStatementChildNodeMatches = assertionNonTerminalNodeMatches; ///
+            bracketedChildNode = bracketedChildNodeFromChildNodes(childNodes);
 
-              return bracketedStatementChildNodeMatches;
-            });
+      if (bracketedChildNode !== null) {
+        const nonTerminalNode = bracketedChildNode,  ///
+              childNodes = nonTerminalNode.getChildNodes(),
+              nodesB = childNodes, ///
+              nodesMatch = matchNodes(nodesA, nodesB);
 
-      matches = bracketedStatementChildNodeMatches; ///
+        matches = nodesMatch; ///
+      }
     }
 
     return matches;
   }
 
-  static fromVariableNameAndNodes(variableName, nodes) {
-    const bracketedStatementChildNode = bracketedStatementChildNodeFromChildNodes(nodes);
+  static fromMetavariableNameAndNodes(variableName, nodes) {
+    const bracketedChildNode = bracketedChildNodeFromChildNodes(nodes);
 
-    if (bracketedStatementChildNode !== null) {
-      const nonTerminalNode = bracketedStatementChildNode,  ///
+    if (bracketedChildNode !== null) {
+      const nonTerminalNode = bracketedChildNode,  ///
             childNodes = nonTerminalNode.getChildNodes();
 
       nodes = childNodes; ///
     }
 
-    const substitution = new Substitution(variableName, nodes);
-
-    return substitution;
-  }
-}
-
-function matchSubstitutionNode(substitutionNode, node) {
-  let substitutionNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = substitutionNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            substitutionTerminalNode = substitutionNode,  ///
-            substitutionTerminalNodeMatches = matchSubstitutionTerminalNode(substitutionTerminalNode, terminalNode);
-
-      substitutionNodeMatches = substitutionTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            substitutionNonTerminalNode = substitutionNode,  ///
-            substitutionNonTerminalNodeMatches = matchSubstitutionNonTerminalNode(substitutionNonTerminalNode, nonTerminalNode);
-
-      substitutionNodeMatches = substitutionNonTerminalNodeMatches; ///
-    }
-  }
-
-  return substitutionNodeMatches;
-}
-
-function matchSubstitutionNodes(substitutionNodes, nodes) {
-  let substitutionNodesMatches = false;
+    const metaSubstitution = new Substitution(variableName, nodes);
 
-  const nodesLength = nodes.length,
-        substitutionNodesLength = substitutionNodes.length;
-
-  if (nodesLength === substitutionNodesLength) {
-    substitutionNodesMatches = nodes.every((node, index) => {
-      const substitutionNode = substitutionNodes[index],
-            substitutionNodeMatches = matchSubstitutionNode(substitutionNode, node);
-
-      if (substitutionNodeMatches) {
-        return true;
-      }
-    })
-  }
-
-  return substitutionNodesMatches;
-}
-
-function matchSubstitutionTerminalNode(substitutionTerminalNode, terminalNode) {
-  const matches = substitutionTerminalNode.match(terminalNode),
-        substitutionTerminalNodeMatches = matches;  ///
-
-  return substitutionTerminalNodeMatches;
-}
-
-function matchSubstitutionNonTerminalNode(substitutionNonTerminalNode, nonTerminalNode) {
-  let substitutionNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        substitutionRuleName = substitutionNonTerminalNode.getRuleName(); ///
-
-  if (ruleName === substitutionRuleName) {
-    const childNodes = nonTerminalNode.getChildNodes(),
-          substitutionChildNodes = substitutionNonTerminalNode.getChildNodes(),
-          nodes = childNodes, ///
-          substitutionNodes = substitutionChildNodes, ///
-          substitutionNodesMatches = matchSubstitutionNodes(substitutionNodes, nodes);
-
-    substitutionNonTerminalNodeMatches = substitutionNodesMatches; ///
+    return metaSubstitution;
   }
-
-  return substitutionNonTerminalNodeMatches;
 }

package/src/utilities/node.js

@@ -1,5 +1,9 @@
 "use strict";
 
+import { first, second, third } from "./array";
+import { METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { BRACKETED_CHILD_NODES_LENGTH, LEFT_BRACKET, RIGHT_BRACKET } from "../constants";
+
 export function matchNode(nodeA, nodeB) {
   let nodeMatches = false;
 
@@ -25,7 +29,7 @@ export function matchNode(nodeA, nodeB) {
   return nodeMatches;
 }
 
-function matchNodes(nodesA, nodesB) {
+export function matchNodes(nodesA, nodesB) {
   let nodesMatch = false;
 
   const nodesALength = nodesA.length,
@@ -45,6 +49,79 @@ function matchNodes(nodesA, nodesB) {
   return nodesMatch;
 }
 
+export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB) {
+  let bracketedNodeMatches = false;
+
+  if (!bracketedNodeMatches) {
+    const nonTerminalNodeMatches = matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
+
+    bracketedNodeMatches = nonTerminalNodeMatches;  ///
+  }
+
+  if (!bracketedNodeMatches) {
+    const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+          childNodesA = nonTerminalNodeAChildNodes, ///
+          bracketedChildNodeA = bracketedChildNodeFromChildNodes(childNodesA);
+
+    if (bracketedChildNodeA !== null) {
+      const nodeA = bracketedChildNodeA,  ///
+            nodeB = nonTerminalNodeB, ///
+            nodeMatches = matchNode(nodeA, nodeB);
+
+      bracketedNodeMatches = nodeMatches; ///
+    }
+  }
+
+  if (!bracketedNodeMatches) {
+    const nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+          childNodesB = nonTerminalNodeBChildNodes, ///
+          bracketedChildNodeB = bracketedChildNodeFromChildNodes(childNodesB);
+
+    if (bracketedChildNodeB !== null) {
+      const nodeB = bracketedChildNodeB,  ///
+            nodeA = nonTerminalNodeA, ///
+            nodeMatches = matchNode(nodeA, nodeB);
+
+      bracketedNodeMatches = nodeMatches; ///
+    }
+  }
+
+  return bracketedNodeMatches;
+}
+
+export function bracketedChildNodeFromChildNodes(childNodes) {
+  let bracketedChildNode = null;
+
+  const childNodesLength = childNodes.length;
+
+  if (childNodesLength === BRACKETED_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),
+            nonTerminalNodeRuleNameMetastatementRuleName = (nonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
+
+      if (firstTerminalNodeContentLeftBracket && nonTerminalNodeRuleNameMetastatementRuleName && secondTerminalNodeContentRightBracket) {
+        bracketedChildNode = nonTerminalNode;  ///
+      }
+    }
+  }
+
+  return bracketedChildNode;
+}
+
 function matchTerminalNode(terminalNodeA, terminalNodeB) {
   const matches = terminalNodeA.match(terminalNodeB),
         terminalNodeMatches = matches;  ///

package/src/verify/derivation.js

@@ -14,14 +14,11 @@ const statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/s
       unqualifiedStatementNodesQuery = nodesQuery("/subproof/unqualifiedStatement")
 
 export default function verifyDerivation(derivationNode, proofContext) {
-  let derivationVerified,
-      derived;
+  let derivationVerified;
 
   proofContext.begin(derivationNode);
 
-  derived = true;
-
-  proofContext.setDerived(derived);
+  proofContext.setDerived();
 
   const derivationChildNodes = derivationChildNodesQuery(derivationNode);
 
@@ -33,9 +30,7 @@ export default function verifyDerivation(derivationNode, proofContext) {
     }
   });
 
-  derived = false;
-
-  proofContext.setDerived(derived);
+  proofContext.setDerived();
 
   derivationVerified ?
     proofContext.complete(derivationNode) :

package/src/verify/metaDerivation.js

@@ -14,14 +14,11 @@ const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMet
       unqualifiedMetastatementNodesQuery = nodesQuery("/metaSubproof/unqualifiedMetastatement")
 
 export default function verifyMetaDerivation(metaDerivationNode, metaproofContext) {
-  let metaDerivationVerified,
-      derived;
+  let metaDerivationVerified;
 
   metaproofContext.begin(metaDerivationNode);
 
-  derived = true;
-
-  metaproofContext.setDerived(derived);
+  metaproofContext.setDerived();
 
   const metaDerivationChildNodes = metaDerivationChildNodesQuery(metaDerivationNode);
 
@@ -33,9 +30,7 @@ export default function verifyMetaDerivation(metaDerivationNode, metaproofContex
     }
   });
 
-  derived = false;
-
-  metaproofContext.setDerived(derived);
+  metaproofContext.resetDerived();
 
   metaDerivationVerified ?
     metaproofContext.complete(metaDerivationNode) :

package/src/verify/metaproof.js

@@ -27,17 +27,11 @@ export default function verifyMetaproof(metaproofNode, conclusion, metaproofCont
   }
 
   if (qualifiedMetastatementNode !== null) {
-    let derived;
-
-    derived = true;
-
-    metaproofContext.setDerived(derived);
+    metaproofContext.setDerived();
 
     qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext);
 
-    derived = false;
-
-    metaproofContext.setDerived(derived);
+    metaproofContext.resetDerived();
 
     if (qualifiedMetastatementVerified) {
       const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),

package/src/verify/metastatement/qualified.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import { nodeAsString } from "../../utilities/string";
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
 const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/reference!"),
@@ -11,10 +10,6 @@ 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) {
@@ -29,10 +24,6 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
     }
   }
 
-  if (qualifiedMetastatementVerified) {
-    metaproofContext.info(`Verified the '${qualifiedMetastatementString}' qualified metastatement.`);
-  }
-
   qualifiedMetastatementVerified ?
     metaproofContext.complete(qualifiedMetastatementNode) :
       metaproofContext.halt(qualifiedMetastatementNode);

package/src/verify/metastatement/unqualified.js

@@ -3,7 +3,6 @@
 import verifyMetastatement from "../../verify/metastatement";
 
 import { nodeQuery } from "../../utilities/query";
-import { nodeAsString } from "../../utilities/string";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
@@ -12,10 +11,6 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
 
   metaproofContext.begin(unqualifiedMetastatementNode);
 
-  const unqualifiedMetastatementString = nodeAsString(unqualifiedMetastatementNode);
-
-  metaproofContext.debug(`Verifying the '${unqualifiedMetastatementString}' unqualified metastatement...`);
-
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
@@ -34,10 +29,6 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
     }
   }
 
-  if (unqualifiedMetastatementVerified) {
-    metaproofContext.info(`Verified the '${unqualifiedMetastatementString}' unqualified metastatement.`);
-  }
-
   unqualifiedMetastatementVerified ?
     metaproofContext.complete(unqualifiedMetastatementNode) :
       metaproofContext.halt(unqualifiedMetastatementNode);

package/src/verify/proof.js

@@ -27,17 +27,11 @@ export default function verifyProof(proofNode, conclusion, proofContext) {
   }
 
   if (qualifiedStatementNode !== null) {
-    let derived;
-
-    derived = true;
-
-    proofContext.setDerived(derived);
+    proofContext.setDerived();
 
     qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, proofContext);
 
-    derived = false;
-
-    proofContext.setDerived(derived);
+    proofContext.resetDerived();
 
     if (qualifiedStatementVerified) {
       const statementNode = statementNodeQuery(qualifiedStatementNode),

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 statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
@@ -13,10 +12,6 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, proofCo
 
   proofContext.begin(qualifiedStatementNode);
 
-  const qualifiedStatementString = nodeAsString(qualifiedStatementNode);
-
-  proofContext.debug(`Verifying the '${qualifiedStatementString}' qualified statement...`);
-
   const statementNode = statementNodeQuery(qualifiedStatementNode);
 
   if (statementNode !== null) {
@@ -33,10 +28,6 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, proofCo
     }
   }
 
-  if (qualifiedStatementVerified) {
-    proofContext.info(`Verified the '${qualifiedStatementString}' qualified statement.`);
-  }
-
   qualifiedStatementVerified ?
     proofContext.complete(qualifiedStatementNode) :
       proofContext.halt(qualifiedStatementNode);

package/src/verify/statement/unqualified.js

@@ -3,7 +3,6 @@
 import verifyStatement from "../../verify/statement";
 
 import { nodeQuery } from "../../utilities/query";
-import { nodeAsString } from "../../utilities/string";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
@@ -12,10 +11,6 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, pro
 
   proofContext.begin(unqualifiedStatementNode);
 
-  const unqualifiedStatementString = nodeAsString(unqualifiedStatementNode);
-
-  proofContext.debug(`Verifying the '${unqualifiedStatementString}' unqualified statement...`);
-
   const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
   if (statementNode !== null) {
@@ -34,10 +29,6 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, pro
     }
   }
 
-  if (unqualifiedStatementVerified) {
-    proofContext.info(`Verified the '${unqualifiedStatementString}' unqualified statement.`);
-  }
-
   unqualifiedStatementVerified ?
     proofContext.complete(unqualifiedStatementNode) :
       proofContext.halt(unqualifiedStatementNode);