occam-verify-cli 0.0.533 → 0.0.535

package/src/verifier/statementForMetavariable.js

@@ -11,8 +11,8 @@ const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
       metaArgumentChildNodeNodeQuery = nodeQuery('/metaArgument/*!');
 
 export default class StatementForMetavariableVerifier extends Verifier {
-  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
-    let nonTerminalNodeMatches = false;
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeVerifies = false;
 
     const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
           nonTerminalNodeBRuleNameMetaArgumentRuleName = (nonTerminalNodeBRuleName === META_ARGUMENT_RULE_NAME);
@@ -23,7 +23,7 @@ export default class StatementForMetavariableVerifier extends Verifier {
 
       nonTerminalNodeB = metaArgumentChildNodeB;  ///
 
-      nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+      nonTerminalNodeVerifies = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
     } else {
       const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
             nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
@@ -33,43 +33,43 @@ export default class StatementForMetavariableVerifier extends Verifier {
       if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameStatementRuleName) {
         const metastatementNodeA = nonTerminalNodeA,  ///
               statementNodeB = nonTerminalNodeB,  ///
-              statementNodeMatches = this.matchStatementNode(metastatementNodeA, statementNodeB, substitutions);
+              statementNodeVerifies = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions);
 
-        if (statementNodeMatches) {
-          nonTerminalNodeMatches = true;  ///
+        if (statementNodeVerifies) {
+          nonTerminalNodeVerifies = true;  ///
         } else {
           const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
                 nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
                 nodesA = nonTerminalNodeAChildNodes, ///
                 nodesB = nonTerminalNodeBChildNodes, ///
-                nodesMatch = this.matchNodes(nodesA, nodesB, substitutions);
+                nodesMatch = this.verifyNodes(nodesA, nodesB, substitutions);
 
-          nonTerminalNodeMatches = nodesMatch;  ///
+          nonTerminalNodeVerifies = nodesMatch;  ///
         }
       } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
-        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        nonTerminalNodeVerifies = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
       }
     }
 
-    return nonTerminalNodeMatches;
+    return nonTerminalNodeVerifies;
   }
 
-  matchStatementNode(metastatementNodeA, statementNodeB, substitutions) {
-    let statementNodeMatches = false;
+  verifyStatementNode(metastatementNodeA, statementNodeB, substitutions) {
+    let statementNodeVerifies = false;
 
     const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if (metavariableNodeA !== null) {
-      const metavariableNodeMatches = this.matchMetavariableNode(metavariableNodeA, statementNodeB, substitutions);
+      const metavariableNodeVerifies = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions);
 
-      statementNodeMatches = metavariableNodeMatches; ///
+      statementNodeVerifies = metavariableNodeVerifies; ///
     }
 
-    return statementNodeMatches;
+    return statementNodeVerifies;
   }
 
-  matchMetavariableNode(metavariableNodeA, statementNodeB, substitutions) {
-    let metavariableNodeMatches;
+  verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions) {
+    let metavariableNodeVerifies;
 
     const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
           substitution = substitutions.find((substitution) => {
@@ -82,9 +82,9 @@ export default class StatementForMetavariableVerifier extends Verifier {
 
     if (substitution !== null) {
       const statementNode = statementNodeB, ///
-            substitutionNodesMatch = substitution.matchStatementNode(statementNode);
+            statementNodeMatches = substitution.matchStatementNode(statementNode);
 
-      metavariableNodeMatches = substitutionNodesMatch;  ///
+      metavariableNodeVerifies = statementNodeMatches;  ///
     } else {
       const { createSubstitutions } = this.constructor;
 
@@ -97,9 +97,9 @@ export default class StatementForMetavariableVerifier extends Verifier {
         substitutions.push(substitution);
       }
 
-      metavariableNodeMatches = true;
+      metavariableNodeVerifies = true;
     }
 
-    return metavariableNodeMatches;
+    return metavariableNodeVerifies;
   }
 }

package/src/verifier/termForVariable.js

@@ -10,8 +10,8 @@ import { variableNameFromVariableNode } from "../utilities/query";
 const variableNodeQuery = nodeQuery('/term/variable!');
 
 export default class TermForVariableVerifier extends Verifier {
-  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
-    let nonTerminalNodeMatches = false;
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeVerifies = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
           nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
@@ -23,37 +23,37 @@ export default class TermForVariableVerifier extends Verifier {
       if (nonTerminalNodeARuleNameTermRuleName && nonTerminalNodeBRuleNameTermRuleName) {
         const termNodeA = nonTerminalNodeA,  ///
               termNodeB = nonTerminalNodeB,  ///
-              termNodeMatches = this.matchTermNode(termNodeA, termNodeB, substitutions);
+              termNodeVerifies = this.verifyTermNode(termNodeA, termNodeB, substitutions);
 
-        if (termNodeMatches) {
-          nonTerminalNodeMatches = true;  ///
+        if (termNodeVerifies) {
+          nonTerminalNodeVerifies = true;  ///
         } else {
-          nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+          nonTerminalNodeVerifies = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
         }
       } else {
-        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        nonTerminalNodeVerifies = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
       }
     }
 
-    return nonTerminalNodeMatches;
+    return nonTerminalNodeVerifies;
   }
 
-  matchTermNode(termNodeA, termNodeB, substitutions) {
-    let termNodeMatches = false;
+  verifyTermNode(termNodeA, termNodeB, substitutions) {
+    let termNodeVerifies = false;
 
     const variableNodeA = variableNodeQuery(termNodeA);
 
     if (variableNodeA !== null) {
-      const variableMatches = this.matchVariableNode(variableNodeA, termNodeB, substitutions);
+      const variableVerifies = this.verifyVariableNode(variableNodeA, termNodeB, substitutions);
 
-      termNodeMatches = variableMatches; ///
+      termNodeVerifies = variableVerifies; ///
     }
 
-    return termNodeMatches;
+    return termNodeVerifies;
   }
 
-  matchVariableNode(variableNodeB, termNodeB, substitutions) {
-    let variableMatches;
+  verifyVariableNode(variableNodeB, termNodeB, substitutions) {
+    let variableVerifies;
 
     const variableNameA = variableNameFromVariableNode(variableNodeB),
           substitution = substitutions.find((substitution) => {
@@ -66,9 +66,9 @@ export default class TermForVariableVerifier extends Verifier {
 
     if (substitution !== null) {
       const termNode = termNodeB, ///
-            substitutionNodesMatch = substitution.matchTermNode(termNode);
+            substitutionNodesVerifies = substitution.matchTermNode(termNode);
 
-      variableMatches = substitutionNodesMatch;  ///
+      variableVerifies = substitutionNodesVerifies;  ///
     } else {
       const { createSubstitutions } = this.constructor;
 
@@ -81,9 +81,9 @@ export default class TermForVariableVerifier extends Verifier {
         substitutions.push(substitution);
       }
 
-      variableMatches = true;
+      variableVerifies = true;
     }
 
-    return variableMatches;
+    return variableVerifies;
   }
 }

package/src/verifier.js

@@ -1,8 +1,8 @@
 "use strict";
 
 export default class Verifier {
-  matchNode(nodeA, nodeB, substitutions) {
-    let nodeMatches = false;
+  verifyNode(nodeA, nodeB, substitutions, context) {
+    let nodeVerifies = false;
 
     const nodeATerminalNode = nodeA.isTerminalNode(),
           nodeBTerminalNode = nodeB.isTerminalNode();
@@ -11,50 +11,50 @@ export default class Verifier {
       if (nodeATerminalNode) {
         const terminalNodeA = nodeA,  ///
               terminalNodeB = nodeB,  ///
-              terminalNodeMatches = this.matchTerminalNode(terminalNodeA, terminalNodeB);
+              terminalNodeVerifies = this.verifyTerminalNode(terminalNodeA, terminalNodeB);
 
-        nodeMatches = terminalNodeMatches;  ///
+        nodeVerifies = terminalNodeVerifies;  ///
       } else {
         const nonTerminalNodeA = nodeA,  ///
               nonTerminalNodeB = nodeB, ///
-              nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+              nonTerminalNodeVerifies = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, context);
 
-        nodeMatches = nonTerminalNodeMatches; ///
+        nodeVerifies = nonTerminalNodeVerifies; ///
       }
     }
 
-    return nodeMatches;
+    return nodeVerifies;
   }
 
-  matchNodes(nodesA, nodesB, substitutions) {
-    let nodesMatch = false;
+  verifyNodes(nodesA, nodesB, substitutions, context) {
+    let nodesVerify = false;
 
     const nodesALength = nodesA.length,
           nodesBLength = nodesB.length;
 
     if (nodesALength === nodesBLength) {
-      nodesMatch = nodesA.every((nodeA, index) => {
+      nodesVerify = nodesA.every((nodeA, index) => {
         const nodeB = nodesB[index],
-              nodeMatches = this.matchNode(nodeA, nodeB, substitutions);
+              nodeVerifies = this.verifyNode(nodeA, nodeB, substitutions, context);
 
-        if (nodeMatches) {
+        if (nodeVerifies) {
           return true;
         }
       })
     }
 
-    return nodesMatch;
+    return nodesVerify;
   }
 
-  matchTerminalNode(terminalNodeA, terminalNodeB, substitutions) {
+  verifyTerminalNode(terminalNodeA, terminalNodeB, substitutions, context) {
     const matches = terminalNodeA.match(terminalNodeB),
-          terminalNodeMatches = matches;  ///
+          terminalNodeVerifies = matches;  ///
 
-    return terminalNodeMatches;
+    return terminalNodeVerifies;
   }
 
-  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
-    let nonTerminalNodeMatches = false;
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, context = null) {
+    let nonTerminalNodeVerifies = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
           nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
@@ -64,11 +64,11 @@ export default class Verifier {
             nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
             nodesA = nonTerminalNodeAChildNodes, ///
             nodesB = nonTerminalNodeBChildNodes, ///
-            nodesMatch = this.matchNodes(nodesA, nodesB, substitutions);
+            nodesVerify = this.verifyNodes(nodesA, nodesB, substitutions, context);
 
-      nonTerminalNodeMatches = nodesMatch; ///
+      nonTerminalNodeVerifies = nodesVerify; ///
     }
 
-    return nonTerminalNodeMatches;
+    return nonTerminalNodeVerifies;
   }
 }

package/src/verify/assertion/type.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Variable from "../../variable";
-import Assertion from "../../assertion";
+import Assignment from "../../assignment";
 
 import { first } from "../../utilities/array";
 import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
@@ -10,7 +10,7 @@ import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verif
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type");
 
-export default function verifyTypeAssertion(typeAssertionNode, assertions, derived, context) {
+export default function verifyTypeAssertion(typeAssertionNode, assignments, derived, context) {
   let typeAssertionVerified = false;
 
   const typeAssertionString = context.nodeAsString(typeAssertionNode);
@@ -25,7 +25,7 @@ export default function verifyTypeAssertion(typeAssertionNode, assertions, deriv
     context.error(`The ${typeName} type is not present.`, typeAssertionNode);
   } else {
     if (!typeAssertionVerified) {
-      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, context);
+      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context);
 
       typeAssertionVerified = variableTypeAssertionVerified;  ///
     }
@@ -44,7 +44,7 @@ export default function verifyTypeAssertion(typeAssertionNode, assertions, deriv
   return typeAssertionVerified;
 }
 
-function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, context) {
+function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context) {
   let variableTypeAssertionVerified = false;
 
   const variables = [],
@@ -88,9 +88,9 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, con
           const type = assertedType,  ///
                 name = variableName,  ///
                 variable = Variable.fromTypeAndName(type, name),
-                assertion = Assertion.fromVariable(variable);
+                assignment = Assignment.fromVariable(variable);
 
-          assertions.push(assertion);
+          assignments.push(assignment);
 
           variableTypeAssertionVerified = true;
         }

package/src/verify/conclusion.js

@@ -16,9 +16,9 @@ export default function verifyConclusion(conclusionNode, conclusions, metaproofC
   metaproofContext.debug(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
 
   const derived = false,
-        assertions = [],
+        assignments = [],
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode),
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assertions, derived, metaproofContext);
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, metaproofContext);
 
   if (unqualifiedMetastatementVerified) {
     const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),

package/src/verify/consequence.js

@@ -16,9 +16,9 @@ export default function verifyConsequence(consequenceNode, consequences, proofCo
   proofContext.debug(`Verifying the '${consequenceString}' consequence...`, consequenceNode);
 
   const derived = false,
-        assertions = [],
+        assignments = [],
         unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequenceNode),
-        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext);
+        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, proofContext);
 
   if (unqualifiedStatementVerified) {
     const statementNode = statementNodeQuery(unqualifiedStatementNode),

package/src/verify/derivation.js

@@ -96,9 +96,9 @@ function verifyChild(childNode, proofContext) {
 
     case QUALIFIED_STATEMENT_RULE_NAME: {
       const derived = true,
-            assertions = [],
+            assignments = [],
             qualifiedStatementNode = childNode,  ///
-            qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assertions, derived, proofContext);
+            qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, proofContext);
 
       if (qualifiedStatementVerified) {
         const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -114,9 +114,9 @@ function verifyChild(childNode, proofContext) {
 
     case UNQUALIFIED_STATEMENT_RULE_NAME: {
       const derived = true,
-            assertions = [],
+            assignments = [],
             unqualifiedStatementNode = childNode,  ///
-            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext);
+            unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, proofContext);
 
       if (unqualifiedStatementVerified) {
         const statementNode = statementNodeQuery(unqualifiedStatementNode),

package/src/verify/metastatement/qualified.js

@@ -7,7 +7,7 @@ import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query
 const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/reference!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
 
-export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, assertions, derived, metaproofContext) {
+export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, metaproofContext) {
   let qualifiedMetastatementVerified = false;
 
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
@@ -31,7 +31,7 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
     }
 
     if (ruleMatchesMetastatement) {
-      const metastatementVerified = verifyMetastatement(metastatementNode, assertions, derived, metaproofContext);
+      const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, metaproofContext);
 
       qualifiedMetastatementVerified = metastatementVerified; ///
     }

package/src/verify/metastatement/unqualified.js

@@ -6,7 +6,7 @@ import { nodeQuery } from "../../utilities/query";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assertions, derived, metaproofContext) {
+export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, metaproofContext) {
   let unqualifiedMetastatementVerified = false;
 
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
@@ -23,7 +23,7 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
     }
 
     if (metastatementMatches) {
-      const metastatementVerified = verifyMetastatement(metastatementNode, assertions, derived, metaproofContext);
+      const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, metaproofContext);
 
       unqualifiedMetastatementVerified = metastatementVerified; ///
     }

package/src/verify/metastatement.js

@@ -1,6 +1,6 @@
 "use strict";
 
-export default function verifyMetastatement(metastatementNode, assertions, derived, metaproofContext) {
+export default function verifyMetastatement(metastatementNode, assignments, derived, metaproofContext) {
   let metastatementVerified = true; ///
 
   ///

package/src/verify/premise.js

@@ -17,9 +17,9 @@ export default function verifyPremise(premiseNode, premises, metaproofContext) {
   metaproofContext.debug(`Verifying the '${premiseString}' premise...`, premiseNode);
 
   const derived = false,
-        assertions = [],
+        assignments = [],
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(premiseNode),
-        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assertions, derived, metaproofContext);
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, metaproofContext);
 
   if (unqualifiedMetastatementVerified) {
     const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),

package/src/verify/ruleDerivation.js

@@ -96,9 +96,9 @@ function verifyChild(childNode, metaproofContext) {
 
     case QUALIFIED_METASTATEMENT_RULE_NAME: {
       const derived = true,
-            assertions = [],
+            assignments = [],
             qualifiedMetastatementNode = childNode,  ///
-            qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, assertions, derived, metaproofContext);
+            qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, metaproofContext);
 
       if (qualifiedMetastatementVerified) {
         const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
@@ -114,9 +114,9 @@ function verifyChild(childNode, metaproofContext) {
 
     case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
       const derived = true,
-            assertions = [],
+            assignments = [],
             unqualifiedMetastatementNode = childNode,  ///
-            unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assertions, derived, metaproofContext);
+            unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, metaproofContext);
 
       if (unqualifiedMetastatementVerified) {
         const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),

package/src/verify/statement/qualified.js

@@ -7,7 +7,7 @@ import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query
 const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
       statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
 
-export default function verifyQualifiedStatement(qualifiedStatementNode, assertions, derived, proofContext) {
+export default function verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, proofContext) {
   let qualifiedStatementVerified = false;
 
   const statementNode = statementNodeQuery(qualifiedStatementNode);
@@ -21,7 +21,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, asserti
 
     if (referenceNode === null) {
       const context = proofContext,
-            statementVerified = verifyStatement(statementNode, assertions, derived, context);
+            statementVerified = verifyStatement(statementNode, assignments, derived, context);
 
       qualifiedStatementVerified = statementVerified; ///
     } else {

package/src/verify/statement/unqualified.js

@@ -6,7 +6,7 @@ import { nodeQuery } from "../../utilities/query";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
-export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext) {
+export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, proofContext) {
   let unqualifiedStatementVerified = false;
 
   const statementNode = statementNodeQuery(unqualifiedStatementNode);
@@ -24,7 +24,7 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
 
     if (statementMatches) {
       const context = proofContext, ///
-            statementVerified = verifyStatement(statementNode, assertions, derived, context);
+            statementVerified = verifyStatement(statementNode, assignments, derived, context);
 
       unqualifiedStatementVerified = statementVerified;  ///
     }