occam-verify-cli 0.0.534 → 0.0.536

package/src/equality.js

@@ -1,6 +1,18 @@
 "use strict";
 
+import matcher from "./matcher";
+import Verifier from "./verifier";
+import verifyTerm from "./verify/term";
+import equalityStatementNode from "./node/statement/equality";
+
+import { nodeQuery } from "./utilities/query";
+import { first, second } from "./utilities/array";
 import { TERM_RULE_NAME } from "./ruleNames";
+import { EQUALITY_DEPTH } from "./constants";
+import { verifyTermAsVariable } from "./verify/term";
+
+const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
+      rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!");
 
 export default class Equality {
   constructor(leftTermNode, rightTermNode) {
@@ -16,7 +28,7 @@ export default class Equality {
     return this.rightTermNode;
   }
 
-  matchTermNodes(leftTermNode, rightTermNode, reversed, context) {
+  matchTermNodes(leftTermNode, rightTermNode, reversed, equalities, context) {
     let leftTermNodeAndRightTermNodeMatch = true;
 
     if (leftTermNodeAndRightTermNodeMatch) {
@@ -24,9 +36,9 @@ export default class Equality {
                                     this.rightTermNode :
                                       this.leftTermNode,  ///
             rightNonTerminalNode = leftTermNode,  ///
-            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, context);
+            nonTerminalNodeVerified = equalityVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context);
 
-      leftTermNodeAndRightTermNodeMatch = nonTerminalNodeEquates; ///
+      leftTermNodeAndRightTermNodeMatch = nonTerminalNodeVerified; ///
     }
 
     if (leftTermNodeAndRightTermNodeMatch) {
@@ -34,30 +46,32 @@ export default class Equality {
                                     this.leftTermNode :
                                       this.rightTermNode,  ///
             rightNonTerminalNode = rightTermNode,  ///
-            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, context);
+            nonTerminalNodeVerified = equalityVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context);
 
-      leftTermNodeAndRightTermNodeMatch = nonTerminalNodeEquates; ///
+      leftTermNodeAndRightTermNodeMatch = nonTerminalNodeVerified; ///
     }
 
     return leftTermNodeAndRightTermNodeMatch;
   }
 
-  match(equality, context) {
+  match(equality, equalities, context) {
     let matches = false;
 
     const leftTermNode = equality.getLeftTermNode(),
           rightTermNode = equality.getRightTermNode();
 
+    equalities = filterEqualities(equalities, equality);  ///
+
     if (!matches) {
       const reversed = false,
-            leftTermNodeAndRightTermNodeMatch = this.matchTermNodes(leftTermNode, rightTermNode, reversed, context);
+            leftTermNodeAndRightTermNodeMatch = this.matchTermNodes(leftTermNode, rightTermNode, reversed, equalities, context);
 
       matches = leftTermNodeAndRightTermNodeMatch;  ///
     }
 
     if (!matches) {
       const reversed = true,
-            leftTermNodeAndRightTermNodeMatch = this.matchTermNodes(leftTermNode, rightTermNode, reversed, context);
+            leftTermNodeAndRightTermNodeMatch = this.matchTermNodes(leftTermNode, rightTermNode, reversed, equalities, context);
 
       matches = leftTermNodeAndRightTermNodeMatch;  ///
     }
@@ -65,13 +79,43 @@ export default class Equality {
     return matches;
   }
 
-  equate(context) {
+  verify(equalities, context) {
     const leftNonTerminalNode = this.leftTermNode,  ///
           rightNonTerminalNode = this.rightTermNode,  ///
-          nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, context),
-          equates = nonTerminalNodeEquates; ///
+          nonTerminalNodeVerified = equalityVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context),
+          verified = nonTerminalNodeVerified; ///
+
+    return verified;
+  }
+
+  static fromProofStep(proofStep) {
+    let equality = null;
+
+    const statementNode = proofStep.getStatementNode();
+
+    if (statementNode !== null) {
+      const nodeA = statementNode,  ///
+            nodeB = equalityStatementNode,  ///
+            depth = EQUALITY_DEPTH,
+            nodeMatches = matcher.matchNode(nodeA, nodeB, depth);
+
+      if (nodeMatches) {
+        const leftTermNode = leftTermNodeQuery(statementNode),
+              rightTermNode = rightTermNodeQuery(statementNode);
+
+        equality = new Equality(leftTermNode, rightTermNode);
+      }
+    }
+
+    return equality;
+  }
 
-    return equates;
+  static fromStatementNode(statementNode) {
+    const leftTermNode = leftTermNodeQuery(statementNode),
+          rightTermNode = rightTermNodeQuery(statementNode),
+          equality = new Equality(leftTermNode, rightTermNode);
+
+    return equality;
   }
 
   static fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode) {
@@ -81,108 +125,138 @@ export default class Equality {
   }
 }
 
-function equateNode(nodeA, nodeB, context) {
-  let nodeEquates = false;
+class EqualityVerifier extends Verifier {
+  verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context) {
+    let nonTerminalNodeVerified = false;
 
-  const nodeATerminalNode = nodeA.isTerminalNode(),
-        nodeBTerminalNode = nodeB.isTerminalNode();
+    const leftNonTerminalNodeRuleName = leftNonTerminalNode.getRuleName(),
+          rightNonTerminalNodeRuleName = rightNonTerminalNode.getRuleName();
 
-  if (nodeATerminalNode === nodeBTerminalNode) {
-    if (nodeATerminalNode) {
-      const terminalNodeA = nodeA,  ///
-            terminalNodeB = nodeB,  ///
-            terminalNodeEquates = equateTerminalNode(terminalNodeA, terminalNodeB, context);
+    if (leftNonTerminalNodeRuleName === rightNonTerminalNodeRuleName) {
+      const ruleName = leftNonTerminalNodeRuleName, ///
+            ruleNameTermRuleName = (ruleName === TERM_RULE_NAME);
 
-      nodeEquates = terminalNodeEquates;  ///
-    } else {
-      const nonTerminalNodeA = nodeA,  ///
-            nonTerminalNodeB = nodeB, ///
-            nonTerminalNodeEquates = equateNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context);
+      if (ruleNameTermRuleName) {
+        const leftTermNode = leftNonTerminalNode, ///
+              rightTermNode = rightNonTerminalNode, ///
+              termNodeVerified = this.verifyTermNode(leftTermNode, rightTermNode, equalities, context);
+
+        nonTerminalNodeVerified = termNodeVerified;  ///
+      }
 
-      nodeEquates = nonTerminalNodeEquates; ///
+      if (!nonTerminalNodeVerified) {
+        const leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
+              rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
+              leftNodes = leftNonTerminalNodeChildNodes, ///
+              rightNodes = rightNonTerminalNodeChildNodes, ///
+              nodesVerified = this.verifyNodes(leftNodes, rightNodes, equalities, context);
+
+        nonTerminalNodeVerified = nodesVerified; ///
+      }
     }
+
+    return nonTerminalNodeVerified;
   }
 
-  return nodeEquates;
-}
+  verifyTermNode(leftTermNode, rightTermNode, equalities, context) {
+    let termNodeVerified = false;
 
-function equateNodes(leftNodes, rightNodes, context) {
-  let nodesEquate = false;
+    const variables = [],
+          leftTermVerifiedAsVariable = verifyTermAsVariable(leftTermNode, variables, context),
+          rightTermVerifiedAsVariable = verifyTermAsVariable(rightTermNode, variables, context);
 
-  const leftNodesLength = leftNodes.length,
-        rightNodesLength = rightNodes.length;
+    let equality = null;
 
-  if (leftNodesLength === rightNodesLength) {
-    nodesEquate = leftNodes.every((LeftNode, index) => {
-      const rightNode = rightNodes[index],
-            nodeEquates = equateNode(LeftNode, rightNode, context);
+    if (leftTermVerifiedAsVariable && rightTermVerifiedAsVariable) {
+      const firstVariable = first(variables),
+            secondVariable = second(variables),
+            leftVariable = firstVariable, ///
+            rightVariable = secondVariable, ///
+            leftVariableType = leftVariable.getType(),
+            rightVariableType = rightVariable.getType(),
+            leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType = leftVariableType.isEqualToOrSubTypeOfOfSuperTypeOf(rightVariableType);
 
-      if (nodeEquates) {
-        return true;
+      if (leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType) {
+        equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode);
       }
-    });
-  }
+    } else if (leftTermVerifiedAsVariable) {
+      const types = [];
 
-  return nodesEquate;
-}
+      verifyTerm(rightTermNode, types, context);
 
-function equateTerminalNode(terminalNodeA, terminalNodeB, context) {
-  const matches = terminalNodeA.match(terminalNodeB),
-        terminalNodeEquates = matches;  ///
+      const firstType = first(types),
+            firstVariable = first(variables),
+            leftVariable = firstVariable, ///
+            rightTermType = firstType,  ///
+            leftVariableType = leftVariable.getType(),
+            leftVariableTypeEqualToOrSuperTypeOfRightTermType = leftVariableType.isEqualToOrSuperTypeOf(rightTermType);
 
-  return terminalNodeEquates;
-}
+      if (leftVariableTypeEqualToOrSuperTypeOfRightTermType) {
+        equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode);
+      }
+    } else if (rightTermVerifiedAsVariable) {
+      const types = [];
 
-function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, context) {
-  let nonTerminalNodeEquates = false;
+      verifyTerm(leftTermNode, types, context);
 
-  const leftNonTerminalNodeRuleName = leftNonTerminalNode.getRuleName(),
-        rightNonTerminalNodeRuleName = rightNonTerminalNode.getRuleName();
+      const firstType = first(types),
+            firstVariable = first(variables),
+            leftTermType = firstType,  ///
+            rightVariable = firstVariable, ///
+            rightVariableType = rightVariable.getType(),
+            rightVariableTypeEqualToOrSuperTypeOfRightTermType = rightVariableType.isEqualToOrSuperTypeOf(leftTermType);
 
-  if (leftNonTerminalNodeRuleName === rightNonTerminalNodeRuleName) {
-    const ruleName = leftNonTerminalNodeRuleName, ///
-          ruleNameTermRuleName = (ruleName === TERM_RULE_NAME);
+      if (rightVariableTypeEqualToOrSuperTypeOfRightTermType) {
+        equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode);
+      }
+    } else {
+      const types = [];
 
-    if (ruleNameTermRuleName) {
-      const leftTermNode = leftNonTerminalNode, ///
-            rightTermNode = rightNonTerminalNode, ///
-            termNodeEquates = equateTermNode(leftTermNode, rightTermNode, context);
+      verifyTerm(leftTermNode, types, context);
 
-      nonTerminalNodeEquates = termNodeEquates;  ///
+      verifyTerm(rightTermNode, types, context);
+
+      const firstType = first(types),
+            secondType = second(types),
+            leftTermType = firstType, ///
+            rightTermType = secondType, ///
+            leftTermTypeEqualToRightTermType = leftTermType.isEqualTo(rightTermType);
+
+      if (leftTermTypeEqualToRightTermType) {
+        equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode);
+      }
     }
 
-    if (!nonTerminalNodeEquates) {
-      const leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
-            rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
-            leftNodes = leftNonTerminalNodeChildNodes, ///
-            rightNodes = rightNonTerminalNodeChildNodes, ///
-            nodesEquate = equateNodes(leftNodes, rightNodes, context);
+    if (equality !== null) {
+      const equalityA = equality, ///
+            equalitiesB = equalities, ///
+            equalityMatches = equalitiesB.some((equalityB) => { ///
+              const equalityAMatchesEqualityB = equalityA.match(equalityB, equalitiesB, context);
 
-      nonTerminalNodeEquates = nodesEquate; ///
+              if (equalityAMatchesEqualityB) {
+                return true;
+              }
+            });
+
+      termNodeVerified = equalityMatches;  ///
     }
-  }
 
-  return nonTerminalNodeEquates;
+    return termNodeVerified;
+  }
 }
 
-function equateTermNode(leftTermNode, rightTermNode, context) {
-  let termNodeEquates = false;
-
-  const equality = equalityFromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, context);
+const equalityVerifier = new EqualityVerifier();
 
-  if (equality !== null) {
-    const equalityA = equality, ///
-          equalitiesB = equalities, ///
-          equalityMatches = equalitiesB.some((equalityB) => { ///
-            const equalityAMatchesEqualityB = equalityA.match(equalityB, equalitiesB, context);
+function filterEqualities(equalities, equality) {
+  const equalityA = equality; ///
 
-            if (equalityAMatchesEqualityB) {
-              return true;
-            }
-          });
+  equalities = equalities.filter((equality) => {
+    const equalityB = equality; ///
 
-    termNodeEquates = equalityMatches;  ///
-  }
+    if (equalityA !== equalityB) {
+      return true;
+    }
+  });
 
-  return termNodeEquates;
+  return equalities;
 }

package/src/log.js

@@ -110,14 +110,16 @@ function formatMessage(level, message, node = null, tokens = null, filePath = nu
     message = `${upperCaseLevel}: ${message}`;
   } else {
     const leastLineIndex = leastLineIndexFromNodeAndTokens(node, tokens),
-          greatestLineIndex = greatestLineIndexFromNodeAndTokens(node, tokens);
+          leastLineNumber = leastLineIndex + 1,
+          greatestLineIndex = greatestLineIndexFromNodeAndTokens(node, tokens),
+          greatestLineNumber = greatestLineIndex + 1;
 
-    if (leastLineIndex === greatestLineIndex) {
-      const lineIndex = leastLineIndex; ///
+    if (leastLineNumber === greatestLineNumber) {
+      const lineNumber = leastLineNumber; ///
 
-      message = `${upperCaseLevel}: ${filePath} (${lineIndex}) - ${message}`;
+      message = `${upperCaseLevel}: ${filePath} (${lineNumber}) - ${message}`;
     } else {
-      message = `${upperCaseLevel}: ${filePath} (${leastLineIndex}-${greatestLineIndex}) - ${message}`;
+      message = `${upperCaseLevel}: ${filePath} (${leastLineNumber}-${greatestLineNumber}) - ${message}`;
     }
   }
 

package/src/node/statement/equality.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import { statementNodeFromStatementString } from "../../utilities/node";
+
+const equalityStatementString = "n=m";
+
+const equalityStatementNode = statementNodeFromStatementString(equalityStatementString);
+
+export default equalityStatementNode;

package/src/premise.js

@@ -43,9 +43,9 @@ export default class Premise {
           const subproofStatementNode = subproofStatementNodes[index],
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
-                nonTerminalNodeVerifies = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                nonTerminalNodeVerified = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
-          if (nonTerminalNodeVerifies) {
+          if (nonTerminalNodeVerified) {
             return true;
           }
         });
@@ -58,8 +58,8 @@ export default class Premise {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeVerifies = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
-          statementNodeMatches = nonTerminalNodeVerifies; ///
+          nonTerminalNodeVerified = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          statementNodeMatches = nonTerminalNodeVerified; ///
 
     return statementNodeMatches;
   }
@@ -85,9 +85,9 @@ export default class Premise {
           const ruleSubproofMetastatementNode = ruleSubproofMetastatementNodes[index],
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                nonTerminalNodeVerifies = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                nonTerminalNodeVerified = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
-          if (nonTerminalNodeVerifies) {
+          if (nonTerminalNodeVerified) {
             return true;
           }
         });
@@ -100,8 +100,8 @@ export default class Premise {
   matchMetastatementNode(metastatementNode, substitutions) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
-          nonTerminalNodeVerifies = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
-          metastatementNodeMatches = nonTerminalNodeVerifies; ///
+          nonTerminalNodeVerified = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          metastatementNodeMatches = nonTerminalNodeVerified; ///
 
     return metastatementNodeMatches;
   }

package/src/supposition.js

@@ -40,9 +40,9 @@ export default class Supposition {
           const subproofStatementNode = subproofStatementNodes[index],
                 nonTerminalNodeA = subproofAssertionStatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
-                nonTerminalNodeVerifies = suppositionTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                nonTerminalNodeVerified = suppositionTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
-          if (nonTerminalNodeVerifies) {
+          if (nonTerminalNodeVerified) {
             return true;
           }
         });
@@ -55,8 +55,8 @@ export default class Supposition {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNodeA = this.statementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeVerifies = suppositionTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
-          statementNodeMatches = nonTerminalNodeVerifies; ///
+          nonTerminalNodeVerified = suppositionTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          statementNodeMatches = nonTerminalNodeVerified; ///
 
     return statementNodeMatches;
   }

package/src/type.js

@@ -60,19 +60,28 @@ export default class Type {
   }
 
   isEqualToOrSubTypeOf(type) {
-    const equalToType = this.isEqualTo(type),
-          subTypeOfType = this.isSubTypeOf(type),
-          equalToTypeOrSubTypeOf = (equalToType || subTypeOfType);
+    const equalTo = this.isEqualTo(type),
+          subTypeOf = this.isSubTypeOf(type),
+          equalToOrSubTypeOf = (equalTo || subTypeOf);
 
-    return equalToTypeOrSubTypeOf;
+    return equalToOrSubTypeOf;
   }
 
   isEqualToOrSuperTypeOf(type) {
-    const equalToType = this.isEqualTo(type),
-          superTypeOfType = this.isSuperTypeOf(type),
-          equalToTypeOrSuperTypeOf = (equalToType || superTypeOfType);
+    const equalTo = this.isEqualTo(type),
+          superTypeOf = this.isSuperTypeOf(type),
+          equalToOrSuperTypeOf = (equalTo || superTypeOf);
+
+    return equalToOrSuperTypeOf;
+  }
+
+  isEqualToOrSubTypeOfOfSuperTypeOf(type) {
+    const equalTo = this.isEqualTo(type),
+          subTypeOf = this.isSubTypeOf(type),
+          superTypeOf = this.isSuperTypeOf(type),
+          equalToOrSubTypeOfOfSuperTypeOf = (equalTo || subTypeOf || superTypeOf);
 
-    return equalToTypeOrSuperTypeOf;
+    return equalToOrSubTypeOfOfSuperTypeOf;
   }
 
   match(type) {

package/src/variable.js

@@ -1,10 +1,9 @@
 "use strict";
 
 export default class Variable {
-  constructor(type, name, termNode) {
+  constructor(type, name) {
     this.type = type;
     this.name = name;
-    this.termNode = termNode;
   }
 
   getType() {
@@ -15,14 +14,6 @@ export default class Variable {
     return this.name;
   }
 
-  getTermNode() {
-    return this.termNode;
-  }
-
-  isUndefined() {
-    return (this.termNode === null);
-  }
-
   matchName(name) {
     const matchesName = (this.name === name);
 
@@ -37,14 +28,7 @@ export default class Variable {
   }
 
   static fromTypeAndName(type, name) {
-    const termNode = null,
-          variable = new Variable(type, name, termNode);
-
-    return variable;
-  }
-
-  static fromTypeNameAndTermNode(type, name, termNode) {
-    const variable = new Variable(type, name, termNode);
+    const variable = new Variable(type, name);
 
     return variable;
   }

package/src/verifier/metastatementForMetavariable.js

@@ -11,7 +11,7 @@ const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
 
 export default class MetastatementForMetavariableVerifier extends Verifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
-    let nonTerminalNodeVerifies = false;
+    let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
           nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
@@ -23,37 +23,37 @@ export default class MetastatementForMetavariableVerifier extends Verifier {
       if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameMetastatementRuleName) {
         const metastatementNodeA = nonTerminalNodeA,  ///
               metastatementNodeB = nonTerminalNodeB,  ///
-              metastatementNodeVerifies = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions);
+              metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions);
 
-        if (metastatementNodeVerifies) {
-          nonTerminalNodeVerifies = true;  ///
+        if (metastatementNodeVerified) {
+          nonTerminalNodeVerified = true;  ///
         } else {
-          nonTerminalNodeVerifies = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
         }
       } else {
-        nonTerminalNodeVerifies = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
       }
     }
 
-    return nonTerminalNodeVerifies;
+    return nonTerminalNodeVerified;
   }
 
   verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions) {
-    let metastatementNodeVerifies = false;
+    let metastatementNodeVerified = false;
 
     const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if (metavariableNodeA !== null) {
-      const metaVariableNodeVerifies = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions);
+      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions);
 
-      metastatementNodeVerifies = metaVariableNodeVerifies; ///
+      metastatementNodeVerified = metaVariableNodeVerified; ///
     }
 
-    return metastatementNodeVerifies;
+    return metastatementNodeVerified;
   }
 
   verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions) {
-    let metavariableNodeVerifies;
+    let metavariableNodeVerified;
 
     const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
           substitution = substitutions.find((substitution) => {
@@ -66,9 +66,9 @@ export default class MetastatementForMetavariableVerifier extends Verifier {
 
     if (substitution !== null) {
       const metastatementNode = metastatementNodeB, ///
-            substitutionNodesMatch = substitution.verifyMetastatementNode(metastatementNode);
+            metastatementNodeMatches = substitution.matchMetastatementNode(metastatementNode);
 
-      metavariableNodeVerifies = substitutionNodesMatch;  ///
+      metavariableNodeVerified = metastatementNodeMatches;  ///
     } else {
       const { createSubstitutions } = this.constructor;
 
@@ -81,9 +81,9 @@ export default class MetastatementForMetavariableVerifier extends Verifier {
         substitutions.push(substitution);
       }
 
-      metavariableNodeVerifies = true;
+      metavariableNodeVerified = true;
     }
 
-    return metavariableNodeVerifies;
+    return metavariableNodeVerified;
   }
 }