occam-verify-cli 0.0.909 → 0.0.911

package/src/metavariable.js

@@ -37,13 +37,13 @@ export default class Metavariable {
   }
 
   matchName(name) {
-    const nameMatches = (this.name === name);
+    const matchesName = (this.name === name);
 
-    return nameMatches;
+    return matchesName;
   }
 
   matchNode(node, localMetaContext) {
-    let nodeMatches = false;
+    let matchesNode = false;
 
     const metavariableNode = node,  ///
           typeNode = typeNodeQuery(metavariableNode);
@@ -57,16 +57,16 @@ export default class Metavariable {
         if (false) {
           ///
         } else if ((termNode === null) && (this.termType === null)) {
-          nodeMatches = true;
+          matchesNode = true;
         } else if ((termNode !== null) && (this.termType !== null)) {
           const termVerifiedAgainstTermType = verifyTermAgainstTermType(termNode, this.termType, localMetaContext);
 
-          nodeMatches = termVerifiedAgainstTermType;  ///
+          matchesNode = termVerifiedAgainstTermType;  ///
         }
       }
     }
 
-    return nodeMatches;
+    return matchesNode;
   }
 
   toJSON(tokens) {

package/src/mixins/nodesVerifier/intrinsiclevel.js

@@ -18,9 +18,9 @@ function verifyVariableNode(variableNodeA, termNodeB, substitutions, localContex
 
   if (substitution !== null) {
     const termNode = termNodeB, ///
-          termNodeMatches = substitution.matchTermNode(termNode);
+          substitutionMatchesTermNode = substitution.matchTermNode(termNode);
 
-    if (termNodeMatches) {
+    if (substitutionMatchesTermNode) {
       const verifiedAhead = verifyAhead();
 
       variableNodeVerified = verifiedAhead;  ///

package/src/mixins/nodesVerifier/metaLevel.js

@@ -15,9 +15,9 @@ function verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitut
 
   if (substitution !== null) {
     const metastatementNode = metastatementNodeB, ///
-          metastatementNodeMatches = substitution.matchMetastatementNode(metastatementNode);
+          substitutionMetastatementNode = substitution.matchMetastatementNode(metastatementNode);
 
-    metavariableNodeVerified = metastatementNodeMatches;  ///
+    metavariableNodeVerified = substitutionMetastatementNode;  ///
   } else {
     const metavariableNode = metavariableNodeA, ///
           metastatementNode = metastatementNodeB, ///

package/src/premise.js

@@ -17,7 +17,7 @@ const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"
       ruleSubproofPremiseMetastatementNodesQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
       metaSubproofMetaSuppositionMetastatementNodesQuery = nodesQuery("/metaSubproof/metaSupposition/unqualifiedMetastatement!/metastatement!"),
       ruleSubproofLastRuleProofStepMetastatementNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/lastRuleProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!"),
-      metaSubproofLastMetaProofStepMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/lastMetaProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
+      metaSubproofLastMetaproofStepMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/lastMetaproofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
 
 export default class Premise {
   constructor(metastatementNode, statementNode) {
@@ -34,7 +34,7 @@ export default class Premise {
   }
 
   matchStatementNode(statementNode, substitutions, fileContext, localContext) {
-    let statementNodeMatches = false;
+    let matchesStatementNode = false;
 
     if (this.metastatementNode !== null) {
       const nonTerminalNodeA = this.metastatementNode,  ///
@@ -48,14 +48,14 @@ export default class Premise {
               return verifiedAhead;
             });
 
-      statementNodeMatches = nonTerminalNodeVerified; ///
+      matchesStatementNode = nonTerminalNodeVerified; ///
     }
 
-    return statementNodeMatches;
+    return matchesStatementNode;
   }
 
   matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {
-    let subproofNodeMatches = false;
+    let matchesSubproofNode = false;
 
     if (this.metastatementNode !== null) {
       const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
@@ -69,7 +69,7 @@ export default class Premise {
               ],
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
-        subproofNodeMatches = match(subproofAssertionMetastatementNodes, subproofStatementNodes, (subproofAssertionMetastatementNode, subproofStatementNode) => {
+        matchesSubproofNode = match(subproofAssertionMetastatementNodes, subproofStatementNodes, (subproofAssertionMetastatementNode, subproofStatementNode) => {
           const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
                 fileContextA = fileContext, ///
@@ -88,11 +88,11 @@ export default class Premise {
       }
     }
 
-    return subproofNodeMatches;
+    return matchesSubproofNode;
   }
 
   matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext) {
-    let ruleSubproofNodeMatches = false;
+    let matchesRuleSubproofNode = false;
 
     if (this.metastatementNode !== null) {
       const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
@@ -106,7 +106,7 @@ export default class Premise {
               ],
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
-        ruleSubproofNodeMatches = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
+        matchesRuleSubproofNode = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
           const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
@@ -125,25 +125,25 @@ export default class Premise {
       }
     }
 
-    return ruleSubproofNodeMatches;
+    return matchesRuleSubproofNode;
   }
 
   matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext) {
-    let metaSubproofNodeMatches = false;
+    let matchesMetaSubproofNode = false;
 
     if (this.metastatementNode !== null) {
       const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
 
       if (subproofAssertionNode !== null) {
         const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
-              metaSubproofLastMetaProofStepMetastatementNode = metaSubproofLastMetaProofStepMetastatementNodeQuery(metaSubproofNode),
+              metaSubproofLastMetaproofStepMetastatementNode = metaSubproofLastMetaproofStepMetastatementNodeQuery(metaSubproofNode),
               metaSubproofMetastatementNodes = [
                 ...metaSubproofMetaSuppositionMetastatementNodes,
-                metaSubproofLastMetaProofStepMetastatementNode
+                metaSubproofLastMetaproofStepMetastatementNode
               ],
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
-        metaSubproofNodeMatches = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
+        matchesMetaSubproofNode = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
           const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
@@ -162,11 +162,11 @@ export default class Premise {
       }
     }
 
-    return metaSubproofNodeMatches;
+    return matchesMetaSubproofNode;
   }
 
   matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
-    let metastatementNodeMatches = false;
+    let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
       const nonTerminalNodeA = this.metastatementNode,  ///
@@ -180,10 +180,10 @@ export default class Premise {
               return verifiedAhead;
             });
 
-      metastatementNodeMatches = nonTerminalNodeVerified; ///
+      matchesMetastatementNode = nonTerminalNodeVerified; ///
     }
 
-    return metastatementNodeMatches;
+    return matchesMetastatementNode;
   }
 
   toJSON(tokens) {

package/src/rule.js

@@ -31,7 +31,7 @@ export default class Rule {
   }
 
   matchStatement(statementNode, localContext) {
-    let statementNatches = false;
+    let matchesStatement = false;
 
     const proofSteps = localContext.getProofSteps(),
           substitutions = [],
@@ -40,14 +40,14 @@ export default class Rule {
     if (premisesMatch) {
       const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, localContext);
 
-      statementNatches = conclusionMatches;  ///
+      matchesStatement = conclusionMatches;  ///
     }
 
-    return statementNatches;
+    return matchesStatement;
   }
 
   matchMetastatement(metastatementNode, localMetaContext) {
-    let metastatementNatches = false;
+    let matchesMetastatement = false;
 
     const metaproofSteps = localMetaContext.getMetaproofSteps(),
           substitutions = [],
@@ -56,14 +56,14 @@ export default class Rule {
     if (premisesMatch) {
       const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, localMetaContext);
 
-      metastatementNatches = conclusionMatches;  ///
+      matchesMetastatement = conclusionMatches;  ///
     }
 
-    return metastatementNatches;
+    return matchesMetastatement;
   }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.labels.some((label) => {
+    const matchesMetavariableNode = this.labels.some((label) => {
       const labelMatchesMetavariableNode = label.matchMetavariableNode(metavariableNode);
 
       if (labelMatchesMetavariableNode) {
@@ -71,7 +71,7 @@ export default class Rule {
       }
     });
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   toJSON(tokens) {
@@ -150,15 +150,15 @@ function matchPremise(premise, proofStep, substitutions, fileContext, localConte
         statementNode = proofStep.getStatementNode();
 
   if (subproofNode !== null) {
-    const subproofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions, fileContext, localContext);
+    const premiseMatchesSubproofNode = premise.matchSubproofNode(subproofNode, substitutions, fileContext, localContext);
 
-    premiseMatches = subproofNodeMatches; ///
+    premiseMatches = premiseMatchesSubproofNode; ///
   }
 
   if (statementNode !== null) {
-    const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, localContext);
+    const premiseMatchesStatementNode = premise.matchStatementNode(statementNode, substitutions, fileContext, localContext);
 
-    premiseMatches = statementNodeMatches;  ///
+    premiseMatches = premiseMatchesStatementNode;  ///
   }
 
   return premiseMatches;
@@ -181,8 +181,8 @@ function matchPremises(premises, proofSteps, substitutions, fileContext, localCo
 }
 
 function matchConclusion(conclusion, statementNode, substitutions, fileContext, localContext) {
-  const statementNodeMatches = conclusion.matchStatementNode(statementNode, substitutions, fileContext, localContext),
-        conclusionMatches = statementNodeMatches; ///
+  const conclusionMatchesStatementNode = conclusion.matchStatementNode(statementNode, substitutions, fileContext, localContext),
+        conclusionMatches = conclusionMatchesStatementNode; ///
 
   return conclusionMatches;
 }
@@ -195,21 +195,21 @@ function metaMatchPremise(premise, metaproofStep, substitutions, fileContext, lo
         metastatementNode = metaproofStep.getMetastatementNode()
 
   if (ruleSubproofNode !== null) {
-    const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext);
+    const premiseMatchesRuleSubproofNode = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext);
 
-    premiseMatches = ruleSubProofNodeMatches; ///
+    premiseMatches = premiseMatchesRuleSubproofNode; ///
   }
 
   if (metaSubproofNode !== null) {
-    const metaSubProofNodeMatches = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
+    const premiseMatchesMetaSubproofNode = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
 
-    premiseMatches = metaSubProofNodeMatches; ///
+    premiseMatches = premiseMatchesMetaSubproofNode; ///
   }
 
   if (metastatementNode !== null) {
-    const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
+    const premiseMatchesMetastatementNode = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
 
-    premiseMatches = metastatementNodeMatches;  ///
+    premiseMatches = premiseMatchesMetastatementNode;  ///
   }
 
   return premiseMatches;
@@ -232,8 +232,8 @@ function metaMatchPremises(premises, metaproofSteps, substitutions, fileContext,
 }
 
 function metaMatchConclusion(conclusion, metastatementNode, substitutions, fileContext, localMetaContext) {
-  const metastatementNodeMatches = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext),
-        conclusionMatches = metastatementNodeMatches; ///
+  const conclusionMatchesMetastatementNode = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext),
+        conclusionMatches = conclusionMatchesMetastatementNode; ///
 
   return conclusionMatches;
 }

package/src/step/metaproof.js

@@ -1,13 +1,5 @@
 "use strict";
 
-import { first, second } from "../utilities/array";
-import { matchMetastatement } from "../utilities/metaproof";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-
-const metastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
-      ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion"),
-      qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/ruleSubproof/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
-
 export default class MetaproofStep {
   constructor(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode) {
     this.statementNode = statementNode;
@@ -32,94 +24,41 @@ export default class MetaproofStep {
     return this.metastatementNode;
   }
 
-  match(metastatementNode) {
-    let matches = false;
-
-    if (!matches) {
-      const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(metastatementNode);
-
-      if (ruleSubproofAssertionNode !== null) {
-        const ruleSubproofAssertionMatches = this.matchRuleSubproofAssertion(ruleSubproofAssertionNode);
-
-        matches = ruleSubproofAssertionMatches;  ///
-      }
-    }
-
-    if (!matches) {
-      const metastatementMatches = this.matchMetastatement(metastatementNode);
-
-      matches = metastatementMatches; ///
-    }
-
-    return matches;
-  }
-
-  matchMetastatement(metastatementNode) {
-    let metastatementMatches = false;
+  matchMetastatementNode(metastatementNode) {
+    let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
-      const metastatementNodeA = metastatementNode, ///
-            metastatementNodeB = this.metastatementNode;  ///
-
-      metastatementMatches = matchMetastatement(metastatementNodeA, metastatementNodeB);
-    }
-
-    return metastatementMatches;
-  }
-
-  matchRuleSubproofAssertion(ruleSubproofAssertionNode) {
-    let ruleSubproofAssertionMatches = false;
-
-    if (this.ruleSubproofNode !== null) {
-      const ruleSubproofAssertionMetastatementNodes = metastatementNodesQuery(ruleSubproofAssertionNode),
-            firstRuleSubproofAssertionMetastatementNode = first(ruleSubproofAssertionMetastatementNodes),
-            qualifiedOrUnqualifiedMetastatementMetastatementNodes = qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery(this.ruleSubproofNode),
-            firstQualifiedOrUnqualifiedMetastatementMetastatementNode = first(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
-
-      const metastatementNodeA = firstRuleSubproofAssertionMetastatementNode,  ///
-            metastatementNodeB = firstQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
-            metastatementMatches = matchMetastatement(metastatementNodeA, metastatementNodeB);
-
-      if (metastatementMatches) {
-        const secondRuleSubproofAssertionMetastatementNode = second(ruleSubproofAssertionMetastatementNodes),
-              secondQualifiedOrUnqualifiedMetastatementMetastatementNode = second(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
-
-        const metastatementNodeA = secondRuleSubproofAssertionMetastatementNode, ///
-              metastatementNodeB = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
-              metastatementMatches = matchMetastatement(metastatementNodeA, metastatementNodeB);
-
-        ruleSubproofAssertionMatches = metastatementMatches; ///
-      }
+      matchesMetastatementNode = this.metastatementNode.match(metastatementNode);
     }
 
-    return ruleSubproofAssertionMatches;
+    return matchesMetastatementNode;
   }
 
   static fromStatementNode(statementNode) {
     const ruleSubproofNode = null,
           metaSubproofNode = null,
           metastatementNode = null,
-          metaProofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
+          metaproofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
 
-    return metaProofStep;
+    return metaproofStep;
   }
 
   static fromRuleSubproofNode(ruleSubproofNode) {
     const statementNode = null,
           metaSubproofNode = null,
           metastatementNode = null,
-          metaProofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
+          metaproofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
 
-    return metaProofStep;
+    return metaproofStep;
   }
 
   static fromMetaSubproofNode(metaSubproofNode) {
     const statementNode = null,
           ruleSubproofNode = null,
           metastatementNode = null,
-          metaProofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
+          metaproofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
 
-    return metaProofStep;
+    return metaproofStep;
 
   }
 
@@ -127,8 +66,8 @@ export default class MetaproofStep {
     const statementNode = null,
           ruleSubproofNode = null,
           metaSubproofNode = null,
-          metaProofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
+          metaproofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
 
-    return metaProofStep;
+    return metaproofStep;
   }
 }

package/src/step/proof.js

@@ -1,8 +1,5 @@
 "use strict";
 
-import { META_ARGUMENT_RULE_NAME } from "../ruleNames";
-import { matchStatementModuloBrackets } from "../utilities/proof";
-
 export default class ProofStep {
   constructor(subproofNode, statementNode) {
     this.subproofNode = subproofNode;
@@ -17,42 +14,27 @@ export default class ProofStep {
     return this.statementNode;
   }
 
-  match(statementNode) {
-    let matches;
-
-    const statementMatches = this.matchStatement(statementNode);
-
-    matches = statementMatches; //
-
-    return matches;
-  }
-
-  matchStatement(statementNode) {
-    let statementMatches = false;
+  matchStatementNode(statementNode) {
+    let matchesStatementNode = false;
 
     if (this.statementNode !== null) {
-      const ruleName = META_ARGUMENT_RULE_NAME,
-            statementNodeA = statementNode, ///
-            statementNodeB = this.statementNode,  ///
-            statementMatchesModuloBrackets = matchStatementModuloBrackets(statementNodeA, statementNodeB, ruleName);
-
-      statementMatches = statementMatchesModuloBrackets;  ///
+      matchesStatementNode = this.statementNode.match(statementNode);
     }
 
-    return statementMatches;
+    return matchesStatementNode;
   }
 
   static fromSubproofNode(subproofNode) {
     const statementNode = null,
-          metaProofStep = new ProofStep(subproofNode, statementNode);
+          proofStep = new ProofStep(subproofNode, statementNode);
 
-    return metaProofStep;
+    return proofStep;
   }
 
   static fromStatementNode(statementNode) {
     const subproofNode = null,
-          metaProofStep = new ProofStep(subproofNode, statementNode);
+          proofStep = new ProofStep(subproofNode, statementNode);
 
-    return metaProofStep;
+    return proofStep;
   }
 }

package/src/substitution/metastatementForMetavariable.js

@@ -2,9 +2,9 @@
 
 import Substitution from "../substitution";
 
-import { bracketedMetastatementChildNodeFromMetastatementNode } from "../utilities/metaproof";
-import {nodeAsString} from "../utilities/string";
-import {metastatementNodeFromMetastatementString, metavariableNodeFromMetavariableString} from "../utilities/node";
+import { nodeAsString } from "../utilities/string";
+import { bracketedMetastatementChildNodeFromMetastatementNode } from "../utilities/match";
+import { metavariableNodeFromMetavariableString, metastatementNodeFromMetastatementString } from "../utilities/node";
 
 export default class MetastatementForMetavariableSubstitution extends Substitution {
   constructor(metavariableNode, metastatementNode) {
@@ -23,27 +23,27 @@ export default class MetastatementForMetavariableSubstitution extends Substituti
   }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+    const matchesMetavariableNode = this.metavariableNode.match(metavariableNode);
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   matchMetastatementNode(metastatementNode) {
-    let metastatementNodeMatches;
+    let matchesMetastatementNode;
 
-    metastatementNodeMatches = this.metastatementNode.match(metastatementNode)
+    matchesMetastatementNode = this.metastatementNode.match(metastatementNode)
 
-    if (!metastatementNodeMatches) {
+    if (!matchesMetastatementNode) {
       const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode);
 
       if (bracketedMetastatementChildNode !== null) {
         const metastatementNode = bracketedMetastatementChildNode; ///
 
-        metastatementNodeMatches = this.metastatementNode.match(metastatementNode);
+        matchesMetastatementNode = this.metastatementNode.match(metastatementNode);
       }
     }
 
-    return metastatementNodeMatches;
+    return matchesMetastatementNode;
   }
 
   toJSON(tokens) {

package/src/substitution/statementForMetavariable.js

@@ -4,7 +4,7 @@ import Substitution from "../substitution";
 import TermForVariableSubstitution from "./termForVariable";
 import verifyStatementAgainstStatement from "../verify/statementAtainstStatement";
 
-import { bracketedStatementChildNodeFromStatementNode } from "../utilities/proof";
+import { bracketedStatementChildNodeFromStatementNode } from "../utilities/match";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
   constructor(metavariableNode, statementNode, substitution) {
@@ -50,9 +50,9 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+    const matchesMetavariableNode = this.metavariableNode.match(metavariableNode);
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
@@ -102,7 +102,9 @@ function matchStatementNode(statementNodeA, statementNodeB, substitution, substi
   let statementNodeMatches;
 
   if (substitution === null) {
-    statementNodeMatches = statementNodeB.match(statementNodeA);
+    const statementNodeAMatchesStatementNodeB = statementNodeB.match(statementNodeA);
+
+    statementNodeMatches = statementNodeAMatchesStatementNodeB; ///
   } else {
     const statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
 

package/src/substitution/termForVariable.js

@@ -34,15 +34,15 @@ export default class TermForVariableSubstitution extends Substitution {
   }
 
   matchTermNode(termNode) {
-    const termNodeMatches = this.termNode.match(termNode);
+    const matchesTermNode = this.termNode.match(termNode);
 
-    return termNodeMatches;
+    return matchesTermNode;
   }
 
   matchVariableNode(variableNode) {
-    const variableNodeMatches = this.variableNode.match(variableNode);
+    const matchesVariableNode = this.variableNode.match(variableNode);
 
-    return variableNodeMatches;
+    return matchesVariableNode;
   }
 
   static fromSubstitutionNode(substitutionNode) {
@@ -91,9 +91,9 @@ function substituteTermNode(termNode, substitutions) {
 
   if (termVariableNode !== null) {
     substitutions.some((substitution) => {
-      const variableNodeMatches = substitution.matchVariableNode(termVariableNode);
+      const substitutionMatchesVariableNode = substitution.matchVariableNode(termVariableNode);
 
-      if (variableNodeMatches) {
+      if (substitutionMatchesVariableNode) {
         termNode = substitution.getTermNode();  ///
 
         return true;
@@ -106,9 +106,9 @@ function substituteTermNode(termNode, substitutions) {
 
 function substituteVariableNode(variableNode, substitutions) {
   substitutions.some((substitution) => {
-    const variableNodeMatches = substitution.matchVariableNode(variableNode);
+    const substitutionMatchesVariableNode = substitution.matchVariableNode(variableNode);
 
-    if (variableNodeMatches) {
+    if (substitutionMatchesVariableNode) {
       const termNode = substitution.getTermNode(),
             termVariableNode = variableNodeQuery(termNode);
 

package/src/substitution.js

@@ -2,32 +2,32 @@
 
 export default class Substitution {
   matchTermNode(termNode) {
-    const termNodeMatches = false;
+    const matchesTermNode = false;
 
-    return termNodeMatches;
+    return matchesTermNode;
   }
 
   matchVariableNode(variableNode) {
-    const variableNodeMatches = false;
+    const matchesMetavariableNode = false;
 
-    return variableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   matchStatementNode(statementNode) {
-    const statementNodeMatches = false;
+    const matchesStatementNode = false;
 
-    return statementNodeMatches;
+    return matchesStatementNode;
   }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = false;
+    const matchesMetavariableNode = false;
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   matchMetastatementNode(metastatementNode) {
-    const metastatementNodeMatches = false;
+    const matchesMetastatementNode = false;
 
-    return metastatementNodeMatches;
+    return matchesMetastatementNode;
   }
 }