occam-verify-cli 0.0.843 → 0.0.845

package/src/context/local.js

@@ -5,12 +5,7 @@ import Equivalence from "../equivalence";
 import contextMixins from "../mixins/context";
 
 import { last } from "../utilities/array";
-import { mergeEquivalences,
-         separateEquivalences,
-         findEquivalenceByTerm,
-         compressDefinedVariables,
-         definedVariablesFromGroundedEquivalences,
-         implicitlyGroundedEquivalencesFromRemainingEquivalencesAndDefinedVariables } from "../utilities/equivalences";
+import { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariablesFromFromEquivalences } from "../utilities/equivalences";
 
 class LocalContext {
   constructor(context, variables, proofSteps, equivalences) {
@@ -90,49 +85,42 @@ class LocalContext {
     return termType;
   }
 
-  isVariableDefined(variable) {
-    let variableDefined = false;
-
-    const equivalences = this.getEquivalences(),
-          remainingEquivalences = [],
-          initiallyGroundedEquivalences = [];
-
-    separateEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences);
-
-    const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.length;
-
-    if (initiallyGroundedEquivalencesLength > 0) {
-      let groundedEquivalences,
-          implicitlyGroundedEquivalences,
-          implicitlyGroundedEquivalencesLength;
-
-      const context = this,
-            definedVariables = [];
-
-      groundedEquivalences = initiallyGroundedEquivalences; ///
-
-      definedVariablesFromGroundedEquivalences(groundedEquivalences, definedVariables, context);
-
-      implicitlyGroundedEquivalences = implicitlyGroundedEquivalencesFromRemainingEquivalencesAndDefinedVariables(remainingEquivalences, definedVariables);
+  isTermGrounded(term) {
+    const context = this,
+          equivalences = this.getEquivalences(),
+          groundedTerms = [],
+          definedVariables = [];
 
-      implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.length;
+    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
 
-      while (implicitlyGroundedEquivalencesLength > 0) {
-        groundedEquivalences = implicitlyGroundedEquivalences;  ///
+    const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
+            const termMatchesGroundedTerm = term.match(groundedTerm);
 
-        definedVariablesFromGroundedEquivalences(groundedEquivalences, definedVariables, context);
+            if (termMatchesGroundedTerm) {
+              return true;
+            }
+          }),
+          termGrounded = termMatchesGroundedTerm; ///
 
-        implicitlyGroundedEquivalences = implicitlyGroundedEquivalencesFromRemainingEquivalencesAndDefinedVariables(remainingEquivalences, definedVariables);
+    return termGrounded;
+  }
 
-        implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.length;
-      }
+  isVariableDefined(variable) {
+    const context = this,
+          equivalences = this.getEquivalences(),
+          groundedTerms = [],
+          definedVariables = [];
 
-      compressDefinedVariables(definedVariables);
+    groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
 
-      const definedVariablesIncludesVariable = definedVariables.includes(variable);
+    const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
+            const variableMatchesDefinedVariable = variable.match(definedVariable);
 
-      variableDefined = definedVariablesIncludesVariable;  ///
-    }
+            if (variableMatchesDefinedVariable) {
+              return true;
+            }
+          }),
+          variableDefined = variableMatchesDefinedVariable; ///
 
     return variableDefined;
   }

package/src/equivalence.js

@@ -107,35 +107,47 @@ export default class Equivalence {
     return termNodesMatch;
   }
 
-  getVariables(context) {
-    const variables = [];
-
+  getGroundedTerms(definedVariables, groundedTerms, context) {
     this.terms.forEach((term) => {
-      term.getVariables(variables, context);
-    });
+      const termGrounded = term.isGrounded(definedVariables, context);
+
+      if (termGrounded) {
+        const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
+          const termMatchesGroundedTerm = term.match(groundedTerm);
+
+          if (termMatchesGroundedTerm) {
+            return true;
+          }
+        })
 
-    return variables;
+        if (!termMatchesGroundedTerm) {
+          const groundedTerm = term;
+
+          groundedTerms.push(groundedTerm);
+        }
+      }
+    });
   }
 
-  isInitiallyGrounded() {
-    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(),
+  isInitiallyGrounded(context) {
+    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(context),
           initiallyGroundedTermsLength = initiallyGroundedTerms.length,
           initiallyGrounded = (initiallyGroundedTermsLength > 0);
 
     return initiallyGrounded;
   }
 
-  isImplicitlyGrounded(definedVariables) {
-    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables),
+  isImplicitlyGrounded(definedVariables, context) {
+    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, context),
           implicitlyGroundedTermsLength = implicitlyGroundedTerms.length,
           implicitlyGrounded = (implicitlyGroundedTermsLength > 0);
 
     return implicitlyGrounded;
   }
 
-  getInitiallyGroundedTerms() {
+  getInitiallyGroundedTerms(context) {
     const initiallyGroundedTerms = this.terms.reduce((initiallyGroundedTerms, term) => {
-      const termInitiallyGrounded = term.isInitiallyGrounded();
+      const termInitiallyGrounded = term.isInitiallyGrounded(context);
 
       if (termInitiallyGrounded) {
         const initiallyGroundedTerm = term; ///
@@ -149,9 +161,9 @@ export default class Equivalence {
     return initiallyGroundedTerms;
   }
 
-  getImplicitlyGroundedTerms(definedVariables) {
+  getImplicitlyGroundedTerms(definedVariables, context) {
     const implicitlyGroundedTerms = this.terms.reduce((implicitlyGroundedTerms, term) => {
-      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables);
+      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, context);
 
       if (termImplicitlyGrounded) {
         const implicitlyGroundedTerm = term; ///

package/src/substitution/statementForMetavariable.js

@@ -2,9 +2,11 @@
 
 import Substitution from "../substitution";
 
+import substitutionNodesVerifier from "../verifier/nodes/substitution";
 import TermForVariableSubstitution from "./termForVariable";
 import intrinsicLevelNodesVerifier from "../verifier/nodes/intrinsicLevel";
 
+import { push } from "../utilities/array";
 import { bracketedStatementChildNodeFromStatementNode } from "../utilities/proof";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
@@ -52,9 +54,9 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     if (this.substitution === null) {
       statementNodeMatches = this.statementNode.match(statementNode);
     } else {
-      const substitution = this.substitution,
-            statementNodeA = statementNode, ///
-            statementNodeB = this.statementNode;  ///
+      const substitution = this.substitution, ///
+            statementNodeA = statementNode,  ///
+            statementNodeB = this.statementNode; ///
 
       statementNodeMatches = matchStatementNode(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
     }
@@ -99,26 +101,56 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 }
 
+function transformSubstitutions(substitutionsA, substitutionsB) {
+  substitutionsA = substitutionsA.map((substitutionA) => {
+    const substitution = substitutionA,  ///
+          substitutions = substitutionsB,
+          termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions);
+
+    substitutionA = termForVariableSubstitution; ///
+
+    return substitutionA;
+  });
+
+  return substitutionsA;
+}
+
 export function matchStatementNode(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
-  let statementNodeMatches;
+  let statementNodeMatches = false;
+
+  const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions),
+        intrinsic = termForVariableSubstitution.isIntrinsic(substitution);
 
-  const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions);
+  let substitutionsA = []; ///
 
-  substitution = termForVariableSubstitution; ///
+  if (intrinsic) {
+    const substitutionA = termForVariableSubstitution;  ///
 
-  substitutions = [ ///
-    substitution
-  ];
+    substitutionsA.push(substitutionA);
+  }
 
-  const nonTerminalNodeA = statementNodeA, ///
+  const nonTerminalNodeA = statementNodeA,  ///
         nonTerminalNodeB = statementNodeB,  ///
-        nonTerminalNodeVerified = intrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+        nonTerminalNodeVerified = substitutionNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutionsA, localContextA, localContextB, () => {
           const verifiedAhead = true;
 
           return verifiedAhead;
         });
 
-  statementNodeMatches = nonTerminalNodeVerified; ///
+  if (nonTerminalNodeVerified) {
+    if (!intrinsic) {
+      const substitutionB = termForVariableSubstitution,  ///
+            substitutionsB = [
+              substitutionB
+            ];
+
+      substitutionsA = transformSubstitutions(substitutionsA, substitutionsB);
+
+      push(substitutions, substitutionsA);
+    }
+
+    statementNodeMatches = true;
+  }
 
   return statementNodeMatches;
 }

package/src/substitution/termForVariable.js

@@ -23,6 +23,16 @@ export default class TermForVariableSubstitution extends Substitution {
     return this.termNode;
   }
 
+  isIntrinsic(substitution) {
+    const termNod = substitution.getTermNode(),
+          variableNode = substitution.getVariableNode(),
+          termNodeMatches = this.termNode.match(termNod),
+          variableNodeMatches = this.variableNode.match(variableNode),
+          intrinsic = ((!termNodeMatches) && (!variableNodeMatches));
+
+    return intrinsic;
+  }
+
   matchTermNode(termNode) {
     const termNodeMatches = this.termNode.match(termNode);
 

package/src/term.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import { filter } from "./utilities/array";
 import { nodesQuery } from "./utilities/query"
 
 const variableNodesQuery = nodesQuery("//variable");
@@ -25,8 +26,9 @@ export default class Term {
     return matches;
   }
 
-  getVariables(variables, context) {
-    const variableNodes = variableNodesQuery(this.node);
+  getVariables(context) {
+    const variables = [],
+          variableNodes = variableNodesQuery(this.node);
 
     variableNodes.forEach((variableNode) => {
       const variable = context.findVariableByVariableNode(variableNode),
@@ -40,31 +42,35 @@ export default class Term {
     return variables;
   }
 
-  isInitiallyGrounded() {
-    const definedVariables = [],
-          implicitlyGrounded = this.isImplicitlyGrounded(definedVariables),
-          initiallyGrounded = implicitlyGrounded; ///
+  isGrounded(definedVariables, context) {
+    const variables = this.getVariables(context);
+
+    filter(variables, (variable) => {
+      const definedVariablesIncludesVariable = definedVariables.includes(variable);
+
+      if (!definedVariablesIncludesVariable) {
+        return true;
+      }
+    });
+
+    const undefinedVariables = variables, ///
+          undefinedVariablesLength = undefinedVariables.length,
+          grounded = (undefinedVariablesLength <= 1);
+
+    return grounded;
+  }
+
+  isInitiallyGrounded(context) {
+    const variables = this.getVariables(context),
+          variablesLength = variables.length,
+          initiallyGrounded = (variablesLength === 0);
 
     return initiallyGrounded;
   }
 
-  isImplicitlyGrounded(definedVariables) {
-    const variableNodes = variableNodesQuery(this.node),
-          variables = definedVariables, ///
-          nodes = variableNodes,  ///
-          implicitlyGrounded = nodes.every((node) => {
-            const variableMatchesNode = variables.some((variable) => {
-              const variableMatchesNode = variable.matchNode(node);
-
-              if (variableMatchesNode) {
-                return true;
-              }
-            });
-
-            if (variableMatchesNode) {
-              return true;
-            }
-          });
+  isImplicitlyGrounded(definedVariables, context) {
+    const grounded = this.isGrounded(definedVariables, context),
+          implicitlyGrounded = grounded;  ///
 
     return implicitlyGrounded;
   }

package/src/utilities/equivalences.js

@@ -1,6 +1,43 @@
 "use strict";
 
-import { push, filter, compress, separate } from "../utilities/array";
+import { push, compress, separate } from "../utilities/array";
+
+export function mergeEquivalences(equivalencesA, equivalencesB, localContext) {
+  const typesA = typesFromEquivalences(equivalencesA, localContext),
+        typesB = typesFromEquivalences(equivalencesB, localContext),
+        types = [
+          ...typesA,
+          ...typesB
+        ];
+
+  compress(types, (typeA, typeB) => {
+    if (typeA === typeB) {
+      return true;
+    }
+  });
+
+  const equivalences = types.map((type) => {
+    let equivalence;
+
+    const equivalenceA = findEquivalenceByType(equivalencesA, type, localContext),
+          equivalenceB = findEquivalenceByType(equivalencesB, type, localContext);
+
+    if ((equivalenceA !== null) && (equivalenceB !== null)) {
+      const leftEquivalence = equivalenceA, ///
+            rightEquivalence = equivalenceB;  ///
+
+      equivalence = Equivalence.merge(leftEquivalence, rightEquivalence);
+    } else if (equivalenceA !== null) {
+      equivalence = equivalenceA; ///
+    } else if (equivalenceB !== null) {
+      equivalence = equivalenceB; ///
+    }
+
+    return equivalence;
+  });
+
+  return equivalences;
+}
 
 export function areTermNodesEqual(leftTermNode, rightTermNode, equivalences) {
   let termNodesEqual;
@@ -46,87 +83,62 @@ export function findEquivalenceByTerm(equivalences, term) {
   return equivalence;
 }
 
-export function mergeEquivalences(equivalencesA, equivalencesB, localContext) {
-  const typesA = typesFromEquivalences(equivalencesA, localContext),
-        typesB = typesFromEquivalences(equivalencesB, localContext),
-        types = [
-          ...typesA,
-          ...typesB
-        ];
+export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context) {
+  let groundedEquivalences,
+      remainingEquivalences,
+      initiallyGroundedEquivalences,
+      implicitlyGroundedEquivalences;
 
-  compress(types, (typeA, typeB) => {
-    if (typeA === typeB) {
-      return true;
-    }
-  });
+  remainingEquivalences = [];
 
-  const equivalences = types.map((type) => {
-    let equivalence;
+  initiallyGroundedEquivalences = [];
 
-    const equivalenceA = findEquivalenceByType(equivalencesA, type, localContext),
-          equivalenceB = findEquivalenceByType(equivalencesB, type, localContext);
+  separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context);
 
-    if ((equivalenceA !== null) && (equivalenceB !== null)) {
-      const leftEquivalence = equivalenceA, ///
-            rightEquivalence = equivalenceB;  ///
+  const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.length;
 
-      equivalence = Equivalence.merge(leftEquivalence, rightEquivalence);
-    } else if (equivalenceA !== null) {
-      equivalence = equivalenceA; ///
-    } else if (equivalenceB !== null) {
-      equivalence = equivalenceB; ///
-    }
+  if (initiallyGroundedEquivalencesLength > 0) {
+    groundedEquivalences = initiallyGroundedEquivalences; ///
 
-    return equivalence;
-  });
+    let implicitlyGroundedEquivalencesLength = 1;
 
-  return equivalences;
-}
+    while (implicitlyGroundedEquivalencesLength > 0) {
+      let definedVariablesLength = 0,
+          previousDefinedVariablesLength = -1;
 
-export function separateEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences) {
-  separate(equivalences, remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
-    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded();
+      while (definedVariablesLength > previousDefinedVariablesLength) {
+        previousDefinedVariablesLength = definedVariablesLength;  ///
 
-    if (!equivalenceInitiallyGrounded) {
-      return true;
-    }
-  });
-}
+        groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context);
 
-export function compressDefinedVariables(definedVariables) {
-  compress(definedVariables, (definedVariableA, definedVariableB) => {
-    if (definedVariableA === definedVariableB) {
-      return true;
-    }
-  });
-}
+        definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context);
 
-export function definedVariablesFromGroundedEquivalences(groundedEquivalences, definedVariables, context) {
-  groundedEquivalences.forEach((groundedEquivalence) => {
-    const variables = groundedEquivalence.getVariables(context);
+        definedVariablesLength = definedVariables.length;
+      }
 
-    push(definedVariables, variables);
-  });
-}
+      equivalences = remainingEquivalences; ///
 
-export function implicitlyGroundedEquivalencesFromRemainingEquivalencesAndDefinedVariables(remainingEquivalences, definedVariables) {
-  const implicitlyGroundedEquivalences = [];
+      remainingEquivalences = [];
 
-  filter(remainingEquivalences, (remainingEquivalence) => {
-    const remainingEquivalenceImplicitlyGrounded = remainingEquivalence.isImplicitlyGrounded(definedVariables);
+      implicitlyGroundedEquivalences = [];
 
-    if (remainingEquivalenceImplicitlyGrounded) {
-      const implicitlyGroundedEquivalence = remainingEquivalence; ///
+      separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context);
 
-      implicitlyGroundedEquivalences.push(implicitlyGroundedEquivalence);
-    }
+      push(groundedEquivalences, implicitlyGroundedEquivalences);
 
-    if (!remainingEquivalenceImplicitlyGrounded) {
-      return true;
+      implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.length;  ///
     }
+  }
+}
+
+function typesFromEquivalences(equivalences, localContext) {
+  const types = equivalences.map((equivalence) => {
+    const type = equivalence.getType(localContext);
+
+    return type;
   });
 
-  return implicitlyGroundedEquivalences;
+  return types;
 }
 
 function findEquivalenceByTermNodes(equivalences, termNodes) {
@@ -141,12 +153,47 @@ function findEquivalenceByTermNodes(equivalences, termNodes) {
   return equivalence;
 }
 
-function typesFromEquivalences(equivalences, localContext) {
-  const types = equivalences.map((equivalence) => {
-    const type = equivalence.getType(localContext);
+function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
+  const terms = groundedTerms,  ///
+        variables = definedVariables; ///
 
-    return type;
+  terms.forEach((term) => {
+    const termVariables = term.getVariables(context);
+
+    termVariables.forEach((termVariable) => {
+      const variablesIncludesTermVariable = variables.includes(termVariable);
+
+      if (!variablesIncludesTermVariable) {
+        const variable = termVariable;  ///
+
+        variables.push(variable);
+      }
+    });
   });
+}
 
-  return types;
+function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context) {
+  separate(equivalences, remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
+    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(context);
+
+    if (!equivalenceInitiallyGrounded) {
+      return true;
+    }
+  });
+}
+
+function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context) {
+  separate(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, (equivalence) => {
+    const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, context);
+
+    if (!equivalenceImplicitlyGrounded) {
+      return true;
+    }
+  });
+}
+
+function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context) {
+  groundedEquivalences.forEach((groundedEquivalence) => {
+    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, context);
+  });
 }

package/src/verifier/nodes/metaLevelToIntrinsicLevel.js

@@ -93,6 +93,31 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     return metaArgumentNodeVerified;
   }
 
+  verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+    let statementNodeVerified;
+
+    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
+
+    if (metavariableNodeA !== null) {
+      const substitutionNodeA = substitutionNodeQuery(metastatementNodeA),
+            metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+
+      statementNodeVerified = metavariableNodeVerified;  ///
+    } else {
+      const nonTerminalNodeA = metastatementNodeA,  ///
+            nonTerminalNodeB = statementNodeB,  ///
+            nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+            childNodesA = nonTerminalNodeAChildNodes, ///
+            childNodesB = nonTerminalNodeBChildNodes, ///
+            childNodesVerified = super.verifyChildNodes(childNodesA, childNodesB, substitutions, fileContextA, localContextB, verifyAhead);
+
+      statementNodeVerified = childNodesVerified;  ///
+    }
+
+    return statementNodeVerified;
+  }
+
   verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
     let metavariableNodeVerified;
 
@@ -136,31 +161,6 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     return metavariableNodeVerified;
   }
 
-  verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
-    let statementNodeVerified;
-
-    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
-
-    if (metavariableNodeA !== null) {
-      const substitutionNodeA = null, ///
-            metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
-
-      statementNodeVerified = metavariableNodeVerified;  ///
-    } else {
-      const nonTerminalNodeA = metastatementNodeA,  ///
-            nonTerminalNodeB = statementNodeB,  ///
-            nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-            childNodesA = nonTerminalNodeAChildNodes, ///
-            childNodesB = nonTerminalNodeBChildNodes, ///
-            childNodesVerified = super.verifyChildNodes(childNodesA, childNodesB, substitutions, fileContextA, localContextB, verifyAhead);
-
-      statementNodeVerified = childNodesVerified;  ///
-    }
-
-    return statementNodeVerified;
-  }
-
   verifyTermNode(termNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
     let termNodeVerified = false;