occam-verify-cli 0.0.902 → 0.0.904

package/src/axiomLemmaTheoremConjecture.js

@@ -5,8 +5,7 @@ import Consequent from "./consequent";
 import Supposition from "./supposition";
 import LocalContext from "./context/local";
 
-import { extract } from "./utilities/array";
-import { someSubArray } from "./utilities/array";
+import { reverse, correlate } from "./utilities/array";
 
 export default class AxiomLemmaTheoremConjecture {
   constructor(labels, suppositions, consequent, localContext) {
@@ -33,35 +32,16 @@ export default class AxiomLemmaTheoremConjecture {
   }
 
   matchStatement(statementNode, localContext) {
-    let statementNatches;
+    let statementNatches = false;
 
-    const suppositionsLength = this.suppositions.length,
-          statementLocalContext = localContext; ///
+    const proofSteps = localContext.getProofSteps(),
+          substitutions = [],
+          suppositionsMatch = matchSuppositions(this.suppositions, proofSteps, substitutions, this.localContext, localContext);
 
-    if (suppositionsLength === 0) {
-      const substitutions = [],
-            consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.localContext, statementLocalContext);
+    if (suppositionsMatch) {
+      const consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.localContext, localContext);
 
-      statementNatches = consequentMatches; ///
-    } else {
-      const proofSteps = statementLocalContext.getProofSteps();
-
-      statementNatches = someSubArray(proofSteps, suppositionsLength, (proofSteps) => {
-        let suppositionsMatchConsequent = false;
-
-        const substitutions = [],
-              suppositionsMatch = matchSuppositions(this.suppositions, proofSteps, substitutions, this.localContext, statementLocalContext);
-
-        if (suppositionsMatch) {
-          const consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.localContext, statementLocalContext);
-
-          suppositionsMatchConsequent = consequentMatches;  ///
-        }
-
-        if (suppositionsMatchConsequent) {
-          return true;
-        }
-      });
+      statementNatches = consequentMatches;  ///
     }
 
     return statementNatches;
@@ -147,27 +127,13 @@ export default class AxiomLemmaTheoremConjecture {
   static fromLabelsSuppositionsConsequentAndLocalContext(Class, labels, suppositions, consequent, localContext) { return new Class(labels, suppositions, consequent, localContext); }
 }
 
-function matchSupposition(supposition, proofSteps, substitutions, localContext, statementLocalContext) {
-  const proofStep = extract(proofSteps, (proofStep) => {
-    const statementNode = proofStep.getStatementNode();
-
-    if (statementNode !== null) {
-      const statementMatches = supposition.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext);
+function matchSuppositions(suppositions, proofSteps, substitutions, localContext, statementLocalContext) {
+  suppositions = reverse(suppositions); ///
 
-      if (statementMatches) {
-        return true;
-      }
-    }
-  }) || null;
+  proofSteps = reverse(proofSteps); ///
 
-  const suppositionMatches = (proofStep !== null);
-
-  return suppositionMatches;
-}
-
-function matchSuppositions(suppositions, proofSteps, substitutions, localContext, statementLocalContext) {
-  const suppositionsMatch = suppositions.every((supposition) => {
-    const suppositionMatches = matchSupposition(supposition, proofSteps, substitutions, localContext, statementLocalContext);
+  const suppositionsMatch = correlate(suppositions, proofSteps, (supposition, proofStep) => {
+    const suppositionMatches = matchSupposition(supposition, proofStep, substitutions, localContext, statementLocalContext);
 
     if (suppositionMatches) {
       return true;
@@ -177,6 +143,20 @@ function matchSuppositions(suppositions, proofSteps, substitutions, localContext
   return suppositionsMatch;
 }
 
+function matchSupposition(supposition, proofStep, substitutions, localContext, statementLocalContext) {
+  let suppositionMatches = false;
+
+  const statementNode = proofStep.getStatementNode();
+
+  if (statementNode !== null) {
+    const statementMatches = supposition.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext);
+
+    suppositionMatches = statementMatches;  ///
+  }
+
+  return suppositionMatches;
+}
+
 function matchConsequent(consequent, statementNode, substitutions, localContext, statementLocalContext) {
   const nonTerminalNodeMatches = consequent.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext),
         consequentMatches = nonTerminalNodeMatches; ///

package/src/conclusion.js

@@ -30,9 +30,9 @@ export default class Conclusion {
             localContextA = localContext, ///
             localContextB = statementLocalContext,  ///
             nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-              const verifyAhead = true;
+              const verifiedAhead = true;
 
-              return verifyAhead;
+              return verifiedAhead;
             });
 
       statementNodeMatches = nonTerminalNodeVerified; ///

package/src/constants.js

@@ -3,7 +3,5 @@
 export const NOT = 'not';
 export const COMMA = ',';
 export const EMPTY_STRING = "";
-export const MAXIMUM_INDEXES_LENGTH = 10;
 export const BRACKETED_STATEMENT_DEPTH = 2;
-export const MAXIMUM_PERMUTATION_LENGTH = 5;
 export const BRACKETED_METASTATEMENT_DEPTH = 1;

package/src/metaLemmaMetatheorem.js

@@ -5,8 +5,7 @@ import MetaConsequent from "./metaConsequent";
 import MetaSupposition from "./metaSupposition";
 import MetastatementForMetavariableSubstitution from "./substitution/metastatementForMetavariable";
 
-import { extract } from "./utilities/array";
-import { someSubArray } from "./utilities/array";
+import { reverse, correlate } from "./utilities/array";
 
 export default class MetaLemmaMetatheorem {
   constructor(labels, metaSuppositions, metaConsequent, substitutions, fileContext) {
@@ -38,34 +37,16 @@ export default class MetaLemmaMetatheorem {
   }
 
   matchMetastatement(metastatementNode, localMetaContext) {
-    let metastatementNatches;
+    let metastatementNatches = false;
 
-    const metaSuppositionsLength = this.metaSuppositions.length;
+    const metaproofSteps = localMetaContext.getProofSteps(),
+          substitutions = [],
+          metaSuppositionsMatch = matchMetaSuppositions(this.metaSuppositions, metaproofSteps, substitutions, this.fileContext, localMetaContext);
 
-    if (metaSuppositionsLength === 0) {
-      const substitutions = [],
-            metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.fileContext, localMetaContext);
+    if (metaSuppositionsMatch) {
+      const metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.fileContext, localMetaContext);
 
-      metastatementNatches = metaConsequentMatches; ///
-    } else {
-      const metaproofSteps = localMetaContext.getProofSteps();
-
-      metastatementNatches = someSubArray(metaproofSteps, metaSuppositionsLength, (metaproofSteps) => {
-        let metaSuppositionsMatchMetaConsequent = false;
-
-        const substitutions = [],
-              metaSuppositionsMatch = matchMetaSuppositions(this.metaSuppositions, metaproofSteps, substitutions, this.fileContext, localMetaContext);
-
-        if (metaSuppositionsMatch) {
-          const metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.fileContext, localMetaContext);
-
-          metaSuppositionsMatchMetaConsequent = metaConsequentMatches;  ///
-        }
-
-        if (metaSuppositionsMatchMetaConsequent) {
-          return true;
-        }
-      });
+      metastatementNatches = metaConsequentMatches;  ///
     }
 
     return metastatementNatches;
@@ -162,43 +143,41 @@ export default class MetaLemmaMetatheorem {
   static fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(Class, labels, metaSuppositions, metaConsequent, substitutions, fileContext) { return new Class(labels, metaSuppositions, metaConsequent, substitutions, fileContext); }
 }
 
-function matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, fileContext, localMetaContext) {
-  const metaproofStep = extract(metaproofSteps, (metaproofStep) => {
-    const metaSubproofNode = metaproofStep.getMetaSubproofNode(),
-          metastatementNode = metaproofStep.getMetastatementNode();
+function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions, fileContext, localMetaContext) {
+  metaSuppositions = reverse(metaSuppositions); ///
 
-    if (metaSubproofNode !== null) {
-      const metaSubProofMatches = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
+  metaproofSteps = reverse(metaproofSteps); ///
 
-      if (metaSubProofMatches) {
-        return true;
-      }
+  const metaSuppositionsMatch = correlate(metaSuppositions, metaproofSteps, (metaSupposition, metaproofStep) => {
+    const metaSuppositionMatches = matchMetaSupposition(metaSupposition, metaproofStep, substitutions, fileContext, localMetaContext);
+
+    if (metaSuppositionMatches) {
+      return true;
     }
+  });
 
-    if (metastatementNode !== null) {
-      const metastatementMatches = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
+  return metaSuppositionsMatch;
+}
 
-      if (metastatementMatches) {
-        return true;
-      }
-    }
-  }) || null;
+function matchMetaSupposition(metaSupposition, metaproofStep, substitutions, fileContext, localMetaContext) {
+  let suppositionMatches = false;
 
-  const metaSuppositionMatches = (metaproofStep !== null);
+  const metaSubproofNode = metaproofStep.getMetaSubproofNode(),
+        metastatementNode = metaproofStep.getMetastatementNode();
 
-  return metaSuppositionMatches;
-}
+  if (metaSubproofNode !== null) {
+    const metaSubProofMatches = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
 
-function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions, fileContext, localMetaContext) {
-  const metaSuppositionsMatch = metaSuppositions.every((metaSupposition) => {
-    const metaSuppositionMatches = matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, fileContext, localMetaContext);
+    suppositionMatches - metaSubProofMatches; ///
+  }
 
-    if (metaSuppositionMatches) {
-      return true;
-    }
-  });
+  if (metastatementNode !== null) {
+    const metastatementMatches = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
 
-  return metaSuppositionsMatch;
+    suppositionMatches - metastatementMatches; ///
+  }
+
+  return suppositionMatches;
 }
 
 function matchMetaConsequent(metaConsequent, metastatementNode, substitutions, fileContext, localMetaContext) {

package/src/rule.js

@@ -4,8 +4,7 @@ import Label from "./label";
 import Premise from "./premise";
 import Conclusion from "./conclusion";
 
-import { extract } from "./utilities/array";
-import { someSubArray } from "./utilities/array";
+import { reverse, correlate } from "./utilities/array";
 
 export default class Rule {
   constructor(labels, premises, conclusion, fileContext) {
@@ -32,68 +31,32 @@ export default class Rule {
   }
 
   matchStatement(statementNode, localContext) {
-    let statementNatches;
+    let statementNatches = false;
 
-    const premisesLength = this.premises.length;
+    const proofSteps = localContext.getProofSteps(),
+          substitutions = [],
+          premisesMatch = matchPremises(this.premises, proofSteps, substitutions, this.fileContext, localContext);
 
-    if (premisesLength === 0) {
-      const substitutions = [],
-            conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, localContext);
+    if (premisesMatch) {
+      const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, localContext);
 
-      statementNatches = conclusionMatches; ///
-    } else {
-      const proofSteps = localContext.getProofSteps();
-
-      statementNatches = someSubArray(proofSteps, premisesLength, (proofSteps) => {
-        let premisesMatchConclusion = false;
-
-        const substitutions = [],
-              premisesMatch = matchPremises(this.premises, proofSteps, substitutions, this.fileContext, localContext);
-
-        if (premisesMatch) {
-          const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, localContext);
-
-          premisesMatchConclusion = conclusionMatches;  ///
-        }
-
-        if (premisesMatchConclusion) {
-          return true;
-        }
-      });
+      statementNatches = conclusionMatches;  ///
     }
 
     return statementNatches;
   }
 
   matchMetastatement(metastatementNode, localMetaContext) {
-    let metastatementNatches;
-
-    const premisesLength = this.premises.length;
-
-    if (premisesLength === 0) {
-      const substitutions = [],
-            conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, localMetaContext);
-
-      metastatementNatches = conclusionMatches; ///
-    } else {
-      const metaproofSteps = localMetaContext.getMetaproofSteps();
-
-      metastatementNatches = someSubArray(metaproofSteps, premisesLength, (metaproofSteps) => {
-        let premisesMatchConclusion = false;
+    let metastatementNatches = false;
 
-        const substitutions = [],
-              premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions, this.fileContext, localMetaContext);
+    const metaproofSteps = localMetaContext.getMetaproofSteps(),
+          substitutions = [],
+          premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions, this.fileContext, localMetaContext);
 
-        if (premisesMatch) {
-          const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, localMetaContext);
+    if (premisesMatch) {
+      const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, localMetaContext);
 
-          premisesMatchConclusion = conclusionMatches;  ///
-        }
-
-        if (premisesMatchConclusion) {
-          return true;
-        }
-      });
+      metastatementNatches = conclusionMatches;  ///
     }
 
     return metastatementNatches;
@@ -180,36 +143,34 @@ export default class Rule {
   }
 }
 
-function matchPremise(premise, proofSteps, substitutions, fileContext, localContext) {
-  const proofStep = extract(proofSteps, (proofStep) => {
-    const subproofNode = proofStep.getSubproofNode(),
-          statementNode = proofStep.getStatementNode();
+function matchPremise(premise, proofStep, substitutions, fileContext, localContext) {
+  let premiseMatches = false;
 
-    if (subproofNode !== null) {
-      const subproofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions, fileContext, localContext);
+  const subproofNode = proofStep.getSubproofNode(),
+        statementNode = proofStep.getStatementNode();
 
-      if (subproofNodeMatches) {
-        return true;
-      }
-    }
+  if (subproofNode !== null) {
+    const subproofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions, fileContext, localContext);
 
-    if (statementNode !== null) {
-      const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, localContext);
+    premiseMatches = subproofNodeMatches; ///
+  }
 
-      if (statementNodeMatches) {
-        return true;
-      }
-    }
-  }) || null;
+  if (statementNode !== null) {
+    const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, localContext);
 
-  const premiseMatches = (proofStep !== null);
+    premiseMatches = statementNodeMatches;  ///
+  }
 
   return premiseMatches;
 }
 
-function matchPremises(premise, proofSteps, substitutions, fileContext, localContext) {
-  const premisesMatch = premise.every((premise) => {
-    const premiseMatches = matchPremise(premise, proofSteps, substitutions, fileContext, localContext);
+function matchPremises(premises, proofSteps, substitutions, fileContext, localContext) {
+  premises = reverse(premises); ///
+
+  proofSteps = reverse(proofSteps); ///
+
+  const premisesMatch = correlate(premises, proofSteps, (premise, proofStep) => {
+    const premiseMatches = matchPremise(premise, proofStep, substitutions, fileContext, localContext);
 
     if (premiseMatches) {
       return true;
@@ -226,45 +187,41 @@ function matchConclusion(conclusion, statementNode, substitutions, fileContext,
   return conclusionMatches;
 }
 
-function metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, localMetaContext) {
-  const metaproofStep = extract(metaproofSteps, (metaproofStep) => {
-    const ruleSubproofNode = metaproofStep.getRuleSubproofNode(),
-          metaSubproofNode = metaproofStep.getMetaSubproofNode(),
-          metastatementNode = metaproofStep.getMetastatementNode()
+function metaMatchPremise(premise, metaproofStep, substitutions, fileContext, localMetaContext) {
+  let premiseMatches = false;
 
-    if (ruleSubproofNode !== null) {
-      const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext);
+  const ruleSubproofNode = metaproofStep.getRuleSubproofNode(),
+        metaSubproofNode = metaproofStep.getMetaSubproofNode(),
+        metastatementNode = metaproofStep.getMetastatementNode()
 
-      if (ruleSubProofNodeMatches) {
-        return true;
-      }
-    }
+  if (ruleSubproofNode !== null) {
+    const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext);
 
-    if (metaSubproofNode !== null) {
-      const metaSubProofNodeMatches = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
+    premiseMatches = ruleSubProofNodeMatches; ///
+  }
 
-      if (metaSubProofNodeMatches) {
-        return true;
-      }
-    }
+  if (metaSubproofNode !== null) {
+    const metaSubProofNodeMatches = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
 
-    if (metastatementNode !== null) {
-      const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
+    premiseMatches = metaSubProofNodeMatches; ///
+  }
 
-      if (metastatementNodeMatches) {
-        return true;
-      }
-    }
-  }) || null;
+  if (metastatementNode !== null) {
+    const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
 
-  const premiseMatches = (metaproofStep !== null);
+    premiseMatches = metastatementNodeMatches;  ///
+  }
 
   return premiseMatches;
 }
 
-function metaMatchPremises(premise, metaproofSteps, substitutions, fileContext, localMetaContext) {
-  const premisesMatch = premise.every((premise) => {
-    const premiseMatches = metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, localMetaContext);
+function metaMatchPremises(premises, metaproofSteps, substitutions, fileContext, localMetaContext) {
+  premises = reverse(premises); ///
+
+  metaproofSteps = reverse(metaproofSteps); ///
+
+  const premisesMatch = correlate(premises, metaproofSteps, (premise, metaproofStep) => {
+    const premiseMatches = metaMatchPremise(premise, metaproofStep, substitutions, fileContext, localMetaContext);
 
     if (premiseMatches) {
       return true;

package/src/ruleNames.js

@@ -1,13 +1,8 @@
 "use strict";
 
-export const SUBPROOF_RULE_NAME = "subproof";
 export const METAVARIABLE_RULE_NAME = "metavariable";
-export const RULE_SUBPROOF_RULE_NAME = "ruleSubproof";
-export const META_SUBPROOF_RULE_NAME = "metaSubproof";
 export const META_ARGUMENT_RULE_NAME = "metaArgument";
-export const QUALIFIED_STATEMENT_RULE_NAME = "qualifiedStatement";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
-export const QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement";
 export const UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";

package/src/utilities/array.js

@@ -2,56 +2,36 @@
 
 import { arrayUtilities } from "necessary";
 
-import permutationsMatrix from "../permutationsMatrix";
+export const { first, second, last, extract, push, match, filter, compress, separate } = arrayUtilities;
 
-import { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } from "../constants";
+export function reverse(array) {
+  array = [ ///
+    ...array
+  ].reverse();
 
-export const { first, second, last, push, prune, extract, match, filter, compress, separate } = arrayUtilities;
-
-export function someSubArray(array, subArrayLength, callback) {
-  let found = false;
-
-  const arrayLength = array.length,
-        indexesLength = arrayLength, ///
-        permutationLength = subArrayLength; ///
-
-  if (permutationLength <= MAXIMUM_PERMUTATION_LENGTH) {
-    let offset,
-        permutations;
-
-    if (indexesLength > MAXIMUM_INDEXES_LENGTH) {
-      offset = indexesLength - MAXIMUM_INDEXES_LENGTH;
-
-      permutations = permutationsMatrix[MAXIMUM_INDEXES_LENGTH][permutationLength];
-    } else {
-      offset = 0;
-
-      permutations = permutationsMatrix[indexesLength][permutationLength];
-    }
-
-    if (permutations !== null) {
-      found = permutations.some((permutation) => {
-        if (permutation !== null) {
-          const subArray = [];
+  return array;
+}
 
-          for (let position = 0; position < permutationLength; position++) {
-            const index = permutation[position] + offset,
-                  element = array[index];
+export function correlate(arrayA, arrayB, callback) {
+  arrayB = [  ///
+    ...arrayB
+  ];
 
-            subArray.push(element);
-          }
+  const correlates = arrayA.every((elementA) => {
+    const elementB = extract(arrayB, (elementB) => {
+      const result = callback(elementA, elementB);
 
-          const passed = callback(subArray);
+      if (result) {
+        return true;
+      }
+    }) || null;
 
-          if (passed) {
-            return true;
-          }
-        }
-      });
+    if (elementB !== null) {
+      return true;
     }
-  }
+  });
 
-  return found;
+  return correlates;
 }
 
 export function leftDifference(arrayA, arrayB) {

package/src/utilities/verifier.js

@@ -1,20 +1,16 @@
 "use strict";
 
 export function verifyNode(nodeQueryMaps, nonTerminalNode, ...remainingArguments) {
-  let nodeVerified;
+  let nodeVerified = false;
 
   nodeVerified = nodeQueryMaps.some((nodeQueryMap) => {
-    let nodeVerified = false;
-
     const { nodeQuery, verifyNode } = nodeQueryMap;
 
     const node = nodeQuery(nonTerminalNode);
 
     if (node !== null) {
       nodeVerified = verifyNode(node, ...remainingArguments);
-    }
 
-    if (nodeVerified) {
       return true;
     }
   });
@@ -23,11 +19,9 @@ export function verifyNode(nodeQueryMaps, nonTerminalNode, ...remainingArguments
 }
 
 export function verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
-  let nodesVerified;
-
-  nodesVerified = nodeQueryMaps.some((nodeQueryMap) => {
-    let nodesVerified = false;
+  let nodesVerified = false;
 
+  nodeQueryMaps.some((nodeQueryMap) => {
     const { nodeQueryA, nodeQueryB, verifyNodes } = nodeQueryMap;
 
     const nodeA = nodeQueryA(nonTerminalNodeA),  ///
@@ -35,9 +29,7 @@ export function verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, .
 
     if ((nodeA !== null) && (nodeB !== null)) {
       nodesVerified = verifyNodes(nodeA, nodeB, ...remainingArguments);
-    }
 
-    if (nodesVerified) {
       return true;
     }
   });