occam-verify-cli 0.0.844 → 0.0.846

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

@@ -26,12 +26,12 @@ export default class Term {
     return matches;
   }
 
-  getVariables(context) {
+  getVariables(localContext) {
     const variables = [],
           variableNodes = variableNodesQuery(this.node);
 
     variableNodes.forEach((variableNode) => {
-      const variable = context.findVariableByVariableNode(variableNode),
+      const variable = localContext.findVariableByVariableNode(variableNode),
             variablesIncludesVariable = variables.includes(variable);
 
       if (!variablesIncludesVariable) {
@@ -42,8 +42,8 @@ export default class Term {
     return variables;
   }
 
-  isGrounded(definedVariables, context) {
-    const variables = this.getVariables(context);
+  isGrounded(definedVariables, localContext) {
+    const variables = this.getVariables(localContext);
 
     filter(variables, (variable) => {
       const definedVariablesIncludesVariable = definedVariables.includes(variable);
@@ -60,16 +60,16 @@ export default class Term {
     return grounded;
   }
 
-  isInitiallyGrounded(context) {
-    const variables = this.getVariables(context),
+  isInitiallyGrounded(localContext) {
+    const variables = this.getVariables(localContext),
           variablesLength = variables.length,
           initiallyGrounded = (variablesLength === 0);
 
     return initiallyGrounded;
   }
 
-  isImplicitlyGrounded(definedVariables, context) {
-    const grounded = this.isGrounded(definedVariables, context),
+  isImplicitlyGrounded(definedVariables, localContext) {
+    const grounded = this.isGrounded(definedVariables, localContext),
           implicitlyGrounded = grounded;  ///
 
     return implicitlyGrounded;

package/src/utilities/array.js

@@ -29,12 +29,6 @@ export function someSubArray(array, subArrayLength, callback) {
       permutations = permutationsMatrix[indexesLength][permutationLength];
     }
 
-    if (subArrayLength === 4) {
-      permutations = [
-        [ 0, 2, 3, 4 ]
-      ];
-    }
-
     if (permutations !== null) {
       found = permutations.some((permutation) => {
         if (permutation !== null) {

package/src/utilities/equivalences.js

@@ -83,7 +83,7 @@ export function findEquivalenceByTerm(equivalences, term) {
   return equivalence;
 }
 
-export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context) {
+export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, localContext) {
   let groundedEquivalences,
       remainingEquivalences,
       initiallyGroundedEquivalences,
@@ -93,7 +93,7 @@ export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalence
 
   initiallyGroundedEquivalences = [];
 
-  separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context);
+  separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, localContext);
 
   const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.length;
 
@@ -109,9 +109,9 @@ export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalence
       while (definedVariablesLength > previousDefinedVariablesLength) {
         previousDefinedVariablesLength = definedVariablesLength;  ///
 
-        groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context);
+        groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, localContext);
 
-        definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context);
+        definedVariablesFromGroundedTerms(groundedTerms, definedVariables, localContext);
 
         definedVariablesLength = definedVariables.length;
       }
@@ -122,7 +122,7 @@ export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalence
 
       implicitlyGroundedEquivalences = [];
 
-      separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context);
+      separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, localContext);
 
       push(groundedEquivalences, implicitlyGroundedEquivalences);
 
@@ -153,12 +153,12 @@ function findEquivalenceByTermNodes(equivalences, termNodes) {
   return equivalence;
 }
 
-function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
+function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, localContext) {
   const terms = groundedTerms,  ///
         variables = definedVariables; ///
 
   terms.forEach((term) => {
-    const termVariables = term.getVariables(context);
+    const termVariables = term.getVariables(localContext);
 
     termVariables.forEach((termVariable) => {
       const variablesIncludesTermVariable = variables.includes(termVariable);
@@ -172,9 +172,9 @@ function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, cont
   });
 }
 
-function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context) {
+function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, localContext) {
   separate(equivalences, remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
-    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(context);
+    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(localContext);
 
     if (!equivalenceInitiallyGrounded) {
       return true;
@@ -182,9 +182,9 @@ function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalenc
   });
 }
 
-function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context) {
+function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, localContext) {
   separate(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, (equivalence) => {
-    const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, context);
+    const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, localContext);
 
     if (!equivalenceImplicitlyGrounded) {
       return true;
@@ -192,8 +192,8 @@ function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalen
   });
 }
 
-function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context) {
+function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, localContext) {
   groundedEquivalences.forEach((groundedEquivalence) => {
-    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, context);
+    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, localContext);
   });
 }

package/src/verifier/node/metastatement.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import LocalContext from "../../context/local";
 import NodeVerifier from "../../verifier/node";
 
 import { verifyStandaloneTerm } from "../../verify/term";
@@ -15,9 +16,8 @@ class MetastatementNodeVerifier extends NodeVerifier {
 
     switch (ruleName) {
       case METAVARIABLE_RULE_NAME: {
-        const context = localMetaContext, ///
-              metavariableNode = nonTerminalNode, ///
-              standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, context, verifyAhead),
+        const metavariableNode = nonTerminalNode, ///
+              standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, localMetaContext, verifyAhead),
               metavariableNodeVerified = standaloneMetavariableVerified;  ///
 
         nonTerminalNodeVerified = metavariableNodeVerified; ///
@@ -26,9 +26,8 @@ class MetastatementNodeVerifier extends NodeVerifier {
       }
 
       case VARIABLE_RULE_NAME: {
-        const context = localMetaContext, ///
-              variableNode = nonTerminalNode, ///
-              standaloneVariableVerified = verifyStandaloneVariable(variableNode, context, verifyAhead),
+        const variableNode = nonTerminalNode, ///
+              standaloneVariableVerified = verifyStandaloneVariable(variableNode, localMetaContext, verifyAhead),
               variableNodeVerified = standaloneVariableVerified;  ///
 
         nonTerminalNodeVerified = variableNodeVerified; ///
@@ -37,9 +36,9 @@ class MetastatementNodeVerifier extends NodeVerifier {
       }
 
       case TERM_RULE_NAME: {
-        const context = localMetaContext, ///
-              termNode = nonTerminalNode, ///
-              standaloneTermVerified = verifyStandaloneTerm(termNode, context, verifyAhead),
+        const termNode = nonTerminalNode, ///
+              localContext = LocalContext.fromLocalMetaContext(localMetaContext),
+              standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
               termNodeVerified = standaloneTermVerified;  ///
 
         nonTerminalNodeVerified = termNodeVerified; ///

package/src/verifier/node/statementAsCombinator.js

@@ -8,16 +8,15 @@ import { verifyStandaloneStatement } from "../../verify/statement";
 import { TYPE_RULE_NAME, TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../../ruleNames";
 
 class StatementAsCombinatorNodeVerifier extends NodeVerifier {
-  verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const ruleName = nonTerminalNode.getRuleName();
 
     switch (ruleName) {
       case STATEMENT_RULE_NAME: {
-        const context = fileContext,  ///
-              statementNode = nonTerminalNode, ///
-              standaloneStatementVerified = verifyStandaloneStatement(statementNode, context, verifyAhead),
+        const statementNode = nonTerminalNode, ///
+              standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext, verifyAhead),
               statementNodeVerified = standaloneStatementVerified; ///
 
         nonTerminalNodeVerified = statementNodeVerified; ///
@@ -26,9 +25,8 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
 
       case TERM_RULE_NAME: {
-        const context = fileContext,  ///
-              termNode = nonTerminalNode, ///
-              standaloneTermVerified = verifyStandaloneTerm(termNode, context, verifyAhead),
+        const termNode = nonTerminalNode, ///
+              standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
               termNodeVerified = standaloneTermVerified;  ///
 
         nonTerminalNodeVerified = termNodeVerified; ///
@@ -37,9 +35,8 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
 
       case TYPE_RULE_NAME: {
-        const context = fileContext,  ///
-              typeNode = nonTerminalNode, ///
-              standaloneTypeVerified = verifyStandaloneType(typeNode, context, verifyAhead),
+        const typeNode = nonTerminalNode, ///
+              standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
               typeNodeVerified = standaloneTypeVerified;  ///
 
         nonTerminalNodeVerified = typeNodeVerified; ///
@@ -48,7 +45,7 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
 
       default: {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead); ///
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead); ///
 
         break;
       }

package/src/verifier/node/termAsConstructor.js

@@ -7,16 +7,15 @@ import { verifyStandaloneTerm } from "../../verify/term";
 import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../../ruleNames";
 
 class TermAsConstructorNodeVerifier extends NodeVerifier {
-  verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const ruleName = nonTerminalNode.getRuleName();
 
     switch (ruleName) {
       case TERM_RULE_NAME: {
-        const context = fileContext,  ///
-              termNode = nonTerminalNode, ///
-              standaloneTermVerified = verifyStandaloneTerm(termNode, context, verifyAhead),
+        const termNode = nonTerminalNode, ///
+              standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
               termNodeVerified = standaloneTermVerified;  ///
 
         nonTerminalNodeVerified = termNodeVerified; ///
@@ -25,9 +24,8 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
       }
 
       case TYPE_RULE_NAME: {
-        const context = fileContext,  ///
-              typeNode = nonTerminalNode, ///
-              standaloneTypeVerified = verifyStandaloneType(typeNode, context, verifyAhead),
+        const typeNode = nonTerminalNode, ///
+              standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
               typeNodeVerified = standaloneTypeVerified;  ///
 
         nonTerminalNodeVerified = typeNodeVerified; ///
@@ -36,7 +34,7 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
       }
 
       default: {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
 
         break;
       }

package/src/verifier/nodes/metaLevel.js

@@ -9,7 +9,7 @@ import { METASTATEMENT_RULE_NAME } from "../../ruleNames";
 const metavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
 
 class MetaLevelNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
@@ -22,7 +22,7 @@ class MetaLevelNodesVerifier extends NodesVerifier {
         case METASTATEMENT_RULE_NAME: {
           const metastatementNodeA = nonTerminalNodeA,  ///
                 metastatementNodeB = nonTerminalNodeB,  ///
-                metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+                metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
           nonTerminalNodeVerified = metastatementNodeVerified;  ///
 
@@ -30,7 +30,7 @@ class MetaLevelNodesVerifier extends NodesVerifier {
         }
 
         default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
           break;
         }
@@ -40,19 +40,19 @@ class MetaLevelNodesVerifier extends NodesVerifier {
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
+  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
     let metastatementNodeVerified;
 
     const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if (metavariableNodeA !== null) {
-      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
       metastatementNodeVerified = metaVariableNodeVerified; ///
     } else {
       const nonTerminalNodeA = metastatementNodeA,  ///
             nonTerminalNodeB = metastatementNodeB, ///
-            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
       metastatementNodeVerified = nonTerminalNodeVerified;  ///
     }

package/src/verifier/nodes/metaLevelToIntrinsicLevel.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import LocalContext from "../../context/local";
 import NodesVerifier from "../../verifier/nodes";
 import TermForVariableSubstitution from "../../substitution/termForVariable";
 import intrinsicLevelNodesVerifierMixins from "../../mixins/nodesVerifier/intrinsiclevel";
@@ -16,7 +15,7 @@ const variableNodeQuery = nodeQuery("/*/variable!"),
       substitutionNodeQuery = nodeQuery("/metastatement/substitution!");
 
 class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName();
@@ -24,7 +23,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     switch (nonTerminalNodeARuleName) {
       case METASTATEMENT_RULE_NAME: {
         const metastatementNodeA = nonTerminalNodeA, ///
-              metaArgumentNodeVerified = this.verifyMetastatementNode(metastatementNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+              metaArgumentNodeVerified = this.verifyMetastatementNode(metastatementNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
         nonTerminalNodeVerified = metaArgumentNodeVerified; ///
 
@@ -33,7 +32,6 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
 
       case TERM_RULE_NAME: {
         const termNodeA = nonTerminalNodeA, ///
-              localContextA = LocalContext.fromFileContext(fileContextA),
               termNodeVerified = this.verifyTermNode(termNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
         nonTerminalNodeVerified = termNodeVerified; ///
@@ -42,14 +40,14 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
       }
 
       default: {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
       }
     }
 
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementNode(metastatementNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+  verifyMetastatementNode(metastatementNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let metastatementNodeVerified;
 
     const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
@@ -57,7 +55,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     switch (nonTerminalNodeBRuleName) {
       case META_ARGUMENT_RULE_NAME: {
         const metaArgumentNodeB = nonTerminalNodeB, ///
-              metaArgumentNodeVerified = this.verifyMetaArgumentNode(metastatementNodeA, metaArgumentNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+              metaArgumentNodeVerified = this.verifyMetaArgumentNode(metastatementNodeA, metaArgumentNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
         metastatementNodeVerified = metaArgumentNodeVerified; ///
 
@@ -66,7 +64,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
 
       case STATEMENT_RULE_NAME: {
         const statementNodeB = nonTerminalNodeB,  ///
-              statementNodeVerified = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+              statementNodeVerified = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
         metastatementNodeVerified = statementNodeVerified;  ///
 
@@ -77,7 +75,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     return metastatementNodeVerified;
   }
 
-  verifyMetaArgumentNode(metastatementNodeA, metaArgumentNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+  verifyMetaArgumentNode(metastatementNodeA, metaArgumentNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let metaArgumentNodeVerified = false;
 
     const statementNodeB = statementNodeQuery(metaArgumentNodeB),
@@ -85,7 +83,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
 
     if ((metavariableNodeA !== null) && (statementNodeB !== null)) {
       const substitutionNodeA = substitutionNodeQuery(metastatementNodeA),
-            metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+            metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
       metaArgumentNodeVerified = metavariableNodeVerified;  ///
     }
@@ -93,7 +91,32 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     return metaArgumentNodeVerified;
   }
 
-  verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+  verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let statementNodeVerified;
+
+    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
+
+    if (metavariableNodeA !== null) {
+      const substitutionNodeA = substitutionNodeQuery(metastatementNodeA),
+            metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, localContextA, 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, localContextA, localContextB, verifyAhead);
+
+      statementNodeVerified = childNodesVerified;  ///
+    }
+
+    return statementNodeVerified;
+  }
+
+  verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let metavariableNodeVerified;
 
     const substitution = substitutions.find((substitution) => {
@@ -105,8 +128,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     }) || null;
 
     if (substitution !== null) {
-      const statementNode = substitution.getStatementNode(),
-            localContextA = LocalContext.fromFileContext(fileContextA);
+      const statementNode = substitution.getStatementNode();
 
       if (substitutionNodeA !== null) {
         const substitutionNode = substitutionNodeA, ///
@@ -136,32 +158,7 @@ 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) {
+  verifyTermNode(termNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let termNodeVerified = false;
 
     const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
@@ -172,14 +169,13 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
 
         if (variableNodeA !== null) {
           const termNodeB = nonTerminalNodeB, ///
-                localContextA = LocalContext.fromFileContext(fileContextA),
                 variableNodeVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
           termNodeVerified = variableNodeVerified; ///
         } else {
           const nonTerminalNodeA = termNodeA, ///
                 nonTerminalNodeB = termNodeB, ///
-                nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+                nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
           termNodeVerified = nonTerminalNodeVerified; ///
         }