occam-verify-cli 0.0.532 → 0.0.534

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);
+            substitutionNodesMatch = substitution.verifyStatementNode(statementNode);
 
-      metavariableNodeMatches = substitutionNodesMatch;  ///
+      metavariableNodeVerifies = substitutionNodesMatch;  ///
     } 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.verifyTermNode(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,54 +1,53 @@
 "use strict";
 
 import Variable from "../../variable";
-import TypeAssertion from "../../assertion/type";
+import Assignment from "../../assignment";
 
 import { first } from "../../utilities/array";
-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, derived, proofContext) {
+export default function verifyTypeAssertion(typeAssertionNode, assignments, derived, context) {
   let typeAssertionVerified = false;
 
-  const typeAssertionString = proofContext.nodeAsString(typeAssertionNode);
+  const typeAssertionString = context.nodeAsString(typeAssertionNode);
 
-  proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
+  context.debug(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
 
   const typeNode = typeNodeQuery(typeAssertionNode),
         typeName = typeNameFromTypeNode(typeNode),
-        typePresent = proofContext.isTypePresentByTypeName(typeName);
+        typePresent = context.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    proofContext.error(`The ${typeName} type is not present.`, typeAssertionNode);
+    context.error(`The ${typeName} type is not present.`, typeAssertionNode);
   } else {
     if (!typeAssertionVerified) {
-      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, proofContext);
+      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context);
 
       typeAssertionVerified = variableTypeAssertionVerified;  ///
     }
 
-    // if (!typeAssertionVerified) {
-    //   const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext);
-    //
-    //   typeAssertionVerified = termTypeAssertionVerified;  ///
-    // }
+    if (!typeAssertionVerified) {
+      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, context);
+
+      typeAssertionVerified = termTypeAssertionVerified;  ///
+    }
   }
 
   if (typeAssertionVerified) {
-    proofContext.info(`Verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);
+    context.info(`Verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);
   }
 
   return typeAssertionVerified;
 }
 
-function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, proofContext) {
+function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context) {
   let variableTypeAssertionVerified = false;
 
-  const context = proofContext, ///
-        variables = [],
+  const variables = [],
         termNode = termNodeQuery(typeAssertionNode),
         termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
 
@@ -56,41 +55,45 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, pro
     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);
+          assertedType = context.findTypeByTypeName(assertedTypeName);
 
-      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.`, typeAssertionNode);
-      } else {
-        variableTypeAssertionVerified = true;
-      }
+    if (assertedType === null) {
+      context.error(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);
     } else {
-      const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
+      const 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();
+
+          context.error(`The '${variableName}' variable's '${variableTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`, typeAssertionNode);
+        } else {
+          variableTypeAssertionVerified = true;
+        }
+      } else {
+        const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
 
-      if (!assertedTypeEqualToOrSubTypeOfVariableType) {
-        const assertedTypeName = assertedType.getName(),
-              variableTypeName = variableType.getName();
+        if (!assertedTypeEqualToOrSubTypeOfVariableType) {
+          const assertedTypeName = assertedType.getName(),
+                variableTypeName = variableType.getName();
 
-        proofContext.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
-      } else {
-        const type = assertedType,  ///
-              name = variableName,  ///
-              variable = Variable.fromTypeAndName(type, name),
-              typeAssertion = TypeAssertion.fromVariable(variable),
-              assertion = typeAssertion;  ///
+          context.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
+        } else {
+          const type = assertedType,  ///
+                name = variableName,  ///
+                variable = Variable.fromTypeAndName(type, name),
+                assignment = Assignment.fromVariable(variable);
 
-        assertions.push(assertion);
+          assignments.push(assignment);
 
-        variableTypeAssertionVerified = true;
+          variableTypeAssertionVerified = true;
+        }
       }
     }
   }
@@ -98,40 +101,38 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, pro
   return variableTypeAssertionVerified;
 }
 
-// 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;
-// }
+function verifyTermTypeAssertion(typeAssertionNode, context) {
+  let termTypeAssertionVerified = false;
+
+  const types = [],
+        termNode = termNodeQuery(typeAssertionNode),
+        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
+
+  if (termVerifiedAgainstConstructors) {
+    const typeNode = typeNodeQuery(typeAssertionNode),
+          typeName = typeNameFromTypeNode(typeNode),
+          assertedTypeName = typeName,  ///
+          assertedType = context.findTypeByTypeName(assertedTypeName);
+
+    if (assertedType === null) {
+      context.error(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);
+    } else {
+      const firstType = first(types),
+            termType = firstType, ///
+            termTypeIsEqualToAssertedType = termType.isEqualTo(assertedType);
+
+      if (!termTypeIsEqualToAssertedType) {
+        const termString = context.nodeAsString(termNode),
+              termTypeName = termType.getName(),
+              assertedTypeName = assertedType.getName();
+
+        context.error(`The '${assertedTypeName}' asserted type is not equal to the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
+      } else {
+        termTypeAssertionVerified = true;
+      }
+    }
+  }
+
+  return termTypeAssertionVerified;
+}
 

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),