occam-verify-cli 0.0.902 → 0.0.903

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;
     }
   });

package/src/verifier/node/statementAsCombinator.js

@@ -41,22 +41,29 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
   }
 
   verifyStatementNode(statementNode, localContext, verifyAhead) {
-    const standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext, verifyAhead),
-          statementNodeVerified = standaloneStatementVerified; ///
+    let statementNodeVerified = false;
+
+    const standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext);
+
+    if (standaloneStatementVerified) {
+      const verifiedAhead = verifyAhead;  ///
+
+      statementNodeVerified = verifiedAhead; ///
+    }
 
     return statementNodeVerified;
   }
 
   verifyTermNode(termNode, localContext, verifyAhead) {
     const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-      termNodeVerified = standaloneTermVerified;  ///
+          termNodeVerified = standaloneTermVerified;  ///
 
     return termNodeVerified;
   }
 
   verifyTypeNode(typeNode, localContext, verifyAhead) {
     const standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
-      typeNodeVerified = standaloneTypeVerified;  ///
+          typeNodeVerified = standaloneTypeVerified;  ///
 
     return typeNodeVerified;
   }

package/src/verifier/nodes/metaLevel.js

@@ -6,7 +6,8 @@ import verifyMetavariableAgainstMetastatement from "../../verify/metavariableAga
 import { nodeQuery } from "../../utilities/query";
 import { verifyNodes } from "../../utilities/verifier";
 
-const metastatementNodeQuery = nodeQuery("/metastatement!"),
+const nonTerminalNodeQuery = nodeQuery("/*"),
+      metastatementNodeQuery = nodeQuery("/metastatement!"),
       metastatementMetavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
 
 class MetaLevelNodesVerifier extends NodesVerifier {
@@ -28,6 +29,22 @@ class MetaLevelNodesVerifier extends NodesVerifier {
 
           nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetastatementNode;  ///
 
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: nonTerminalNodeQuery,
+        nodeQueryB: nonTerminalNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const nonTerminalNodeA = nodeA, ///
+                nonTerminalNodeB = nodeB; ///
+
+          nonTerminalNodeVerified =
+
+            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+
           return nonTerminalNodeVerified;
         }
       }
@@ -35,9 +52,7 @@ class MetaLevelNodesVerifier extends NodesVerifier {
 
     const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
 
-    nonTerminalNodeVerified = nodesVerified ?
-                                true :
-                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+    nonTerminalNodeVerified = nodesVerified;  ///
 
     return nonTerminalNodeVerified;
   }

package/src/verify/containedAssertion.js

@@ -4,7 +4,7 @@ import { isAssertionNegated } from "../utilities/verify";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/containedAssertion/term/variable!"),
-      metastatementVariableNodesQuery = nodesQuery("/containedAssertion/metastatement//variable");
+      metastatementVariableNodesQuery = nodesQuery("/containedAssertion/statement//variable");
 
 export default function verifyContainedAssertion(containedAssertionNode) {
   let containedAssertionVerified = false;

package/src/verify/premise.js

@@ -29,8 +29,6 @@ export default function verifyPremise(premiseNode, premises, localMetaContext) {
 
       premiseVerified = assignmentAssigned; ///
     }
-  } else {
-    debugger
   }
 
   if (premiseVerified) {

package/src/verify/statement/qualified.js

@@ -33,11 +33,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
   if (qualifiedStatementVerified) {
     const derived = false,
           statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+          statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
     qualifiedStatementVerified = statementVerified;  ///
   }
@@ -169,7 +165,7 @@ function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, meta
   return qualifiedStatementVerifiedAgainstConjecture;
 }
 
-function verifyStatement(statementNode, assignments, derived, localContext, verifyAhead) {
+function verifyStatement(statementNode, assignments, derived, localContext) {
   let statementVerified;
 
   const statementString = localContext.nodeAsString(statementNode);
@@ -182,7 +178,7 @@ function verifyStatement(statementNode, assignments, derived, localContext, veri
   ];
 
   verifyStatementFunctions.some((verifyStatementFunction) => {
-    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext, verifyAhead);
+    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
 
     if (statementVerified) {
       return true;

package/src/verify/statement/unqualified.js

@@ -21,11 +21,7 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
   }
 
   if (!unqualifiedStatementVerified) {
-    const statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+    const statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
     unqualifiedStatementVerified = statementVerified;  ///
   }

package/src/verify/statement.js

@@ -10,12 +10,12 @@ import statementAgainstCombinatorNodesVerifier from "../verifier/nodes/statement
 import { nodeQuery } from "../utilities/query";
 
 const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      statementNodeQuery = nodeQuery("/containedAssertion/metastatement/statement!"),
+      statementNodeQuery = nodeQuery("/containedAssertion/statement!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
       definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
       containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
 
-function verifyStatement(statementNode, assignments, derived, localContext, verifyAhead) {
+function verifyStatement(statementNode, assignments, derived, localContext) {
   let statementVerified;
 
   const statementString = localContext.nodeAsString(statementNode);
@@ -31,7 +31,7 @@ function verifyStatement(statementNode, assignments, derived, localContext, veri
   ];
 
   statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
-    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext, verifyAhead);
+    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
 
     if (statementVerified) {
       return true;
@@ -45,7 +45,7 @@ function verifyStatement(statementNode, assignments, derived, localContext, veri
   return statementVerified;
 }
 
-export function verifyStandaloneStatement(statementNode, localContext, verifyAhead) {
+export function verifyStandaloneStatement(statementNode, localContext) {
   let standaloneStatementVerified;
 
   const statementString = localContext.nodeAsString(statementNode);
@@ -54,7 +54,7 @@ export function verifyStandaloneStatement(statementNode, localContext, verifyAhe
 
   const derived = false,
         assignments = [],
-        statementVerified = verifyStatement(statementNode, assignments, derived, localContext, verifyAhead);
+        statementVerified = verifyStatement(statementNode, assignments, derived);
 
   standaloneStatementVerified = statementVerified;  ///
 
@@ -71,7 +71,7 @@ Object.assign(statementAgainstCombinatorNodesVerifier, {
 
 export default verifyStatement;
 
-export function verifyStatementAsEquality(statementNode, assignments, derived, localContext, verifyAhead) {
+export function verifyStatementAsEquality(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsEquality = false;
 
   const equalityNode = equalityNodeQuery(statementNode);
@@ -81,7 +81,11 @@ export function verifyStatementAsEquality(statementNode, assignments, derived, l
 
     localContext.trace(`Verifying the '${statementString}' statement as an equality...`, equalityNode);
 
-    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, verifyAhead);
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
 
     statementVerifiedAsEquality = equalityVerified; ///
 
@@ -93,7 +97,7 @@ export function verifyStatementAsEquality(statementNode, assignments, derived, l
   return statementVerifiedAsEquality;
 }
 
-export function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext, verifyAhead) {
+export function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsTypeAssertion = false;
 
   const typeAssertionNode = typeAssertionNodeQuery(statementNode);
@@ -103,7 +107,11 @@ export function verifyStatementAsTypeAssertion(statementNode, assignments, deriv
 
     localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`, typeAssertionNode);
 
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, verifyAhead);
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
 
     statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
 
@@ -115,7 +123,7 @@ export function verifyStatementAsTypeAssertion(statementNode, assignments, deriv
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext, verifyAhead) {
+function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsDefinedAssertion = false;
 
   const definedAssertionNode = definedAssertionNodeQuery(statementNode);
@@ -125,7 +133,11 @@ function verifyStatementAsDefinedAssertion(statementNode, assignments, derived,
 
     localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, definedAssertionNode);
 
-    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, localContext, verifyAhead);
+    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, localContext, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
 
     statementVerifiedAsDefinedAssertion = definedAssertionVerified; ///
 
@@ -137,7 +149,7 @@ function verifyStatementAsDefinedAssertion(statementNode, assignments, derived,
   return statementVerifiedAsDefinedAssertion;
 }
 
-function verifyStatementAsContainedAssertion(statementNode, assignments, derived, localContext, verifyAhead) {
+function verifyStatementAsContainedAssertion(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsContainedAssertion = false;
 
   const containedAssertionNode = containedAssertionNodeQuery(statementNode);
@@ -160,7 +172,7 @@ function verifyStatementAsContainedAssertion(statementNode, assignments, derived
       const statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
         const derived = false,
               assignments = [],
-              statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext, verifyAhead);
+              statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext);
 
         if (statementVerified) {
           return true;
@@ -178,7 +190,7 @@ function verifyStatementAsContainedAssertion(statementNode, assignments, derived
   return statementVerifiedAsContainedAssertion;
 }
 
-function verifyStatementAgainstCombinators(statementNode, assignments, derived, localContext, verifyAhead) {
+function verifyStatementAgainstCombinators(statementNode, assignments, derived, localContext) {
   let statementVerifiedAgainstCombinators = false;
 
   const equalityNode = equalityNodeQuery(statementNode),
@@ -195,7 +207,7 @@ function verifyStatementAgainstCombinators(statementNode, assignments, derived,
     ];
 
     statementVerifiedAgainstCombinators = combinators.some((combinator) => {
-      const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, localContext, verifyAhead);
+      const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, localContext);
 
       if (statementVerifiedAgainstCombinator) {
         return true;
@@ -206,7 +218,7 @@ function verifyStatementAgainstCombinators(statementNode, assignments, derived,
   return statementVerifiedAgainstCombinators;
 }
 
-function verifyStatementAgainstCombinator(statementNode, combinator, localContext, verifyAhead) {
+function verifyStatementAgainstCombinator(statementNode, combinator, localContext) {
   let statementVerifiedAgainstCombinator;
 
   const statementString = localContext.nodeAsString(statementNode),
@@ -217,7 +229,11 @@ function verifyStatementAgainstCombinator(statementNode, combinator, localContex
   const combinatorStatementNode = combinator.getStatementNode(),
         nonTerminalNodeA = statementNode, ///
         nonTerminalNodeB = combinatorStatementNode, ///
-        nonTerminalNodeVerified = statementAgainstCombinatorNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
+        nonTerminalNodeVerified = statementAgainstCombinatorNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, () => {
+          const verifiedAhead = true;
+
+          return verifiedAhead;
+        });
 
   statementVerifiedAgainstCombinator = nonTerminalNodeVerified;  ///