occam-verify-cli 0.0.501 → 0.0.503

package/src/axiomLemmaTheorem.js

@@ -1,29 +1,29 @@
 "use strict";
 
 import Label from "./label";
-import Antecedent from "./antecedent";
-import Consequent from "./consequent";
+import Consequence from "./consequence";
+import Supposition from "./supposition";
 
 import { prune } from "./utilities/array";
 import { someSubArray } from "./utilities/array";
 
 export default class AxiomLemmaTheorem {
-  constructor(labels, antecedents, consequent) {
+  constructor(labels, suppositions, consequence) {
     this.labels = labels;
-    this.antecedents = antecedents;
-    this.consequent = consequent;
+    this.suppositions = suppositions;
+    this.consequence = consequence;
   }
 
   getLabels() {
     return this.labels;
   }
 
-  getAntecedents() {
-    return this.antecedents;
+  getSuppositions() {
+    return this.suppositions;
   }
 
-  getConsequent() {
-    return this.consequent;
+  getConsequence() {
+    return this.consequence;
   }
 
   matchLabelName(labelName) {
@@ -42,20 +42,20 @@ export default class AxiomLemmaTheorem {
   matchStatement(statementNode, proofContext) {
     let statementNatches;
 
-    const antecedentsLength = this.antecedents.length;
+    const suppositionsLength = this.suppositions.length;
 
-    if (antecedentsLength === 0) {
+    if (suppositionsLength === 0) {
       const substitutions = [],
-            consequentMatches = matchConsequent(this.consequent, statementNode, substitutions);
+            consequenceMatches = matchConsequence(this.consequence, statementNode, substitutions);
 
-      statementNatches = consequentMatches; ///
+      statementNatches = consequenceMatches; ///
     } else {
       const proofSteps = proofContext.getProofSteps();
 
-      statementNatches = someSubArray(proofSteps, antecedentsLength, (proofSteps) => {
-        const antecedentsMatchConsequent = matchAntecedentsAndConsequent(this.antecedents, this.consequent, proofSteps, statementNode);
+      statementNatches = someSubArray(proofSteps, suppositionsLength, (proofSteps) => {
+        const suppositionsMatchConsequence = matchSuppositionsAndConsequence(this.suppositions, this.consequence, proofSteps, statementNode);
 
-        if (antecedentsMatchConsequent) {
+        if (suppositionsMatchConsequence) {
           return true;
         }
       });
@@ -71,20 +71,20 @@ export default class AxiomLemmaTheorem {
 
             return labelJSON;
           }),
-          antecedentsJSON = this.antecedents.map((antecedent) => {
-            const antecedentJSON = antecedent.toJSON();
+          suppositionsJSON = this.suppositions.map((supposition) => {
+            const suppositionJSON = supposition.toJSON();
 
-            return antecedentJSON;
+            return suppositionJSON;
           }),
-          consequentJSON = this.consequent.toJSON(),
+          consequenceJSON = this.consequence.toJSON(),
           labels = labelsJSON,  ///
-          antecedents = antecedentsJSON,  ///
-          consequent = consequentJSON,  ///
+          suppositions = suppositionsJSON,  ///
+          consequence = consequenceJSON,  ///
           json = {
             kind,
             labels,
-            antecedents,
-            consequent
+            suppositions,
+            consequence
           };
 
     return json;
@@ -102,38 +102,38 @@ export default class AxiomLemmaTheorem {
       return label;
     });
 
-    let { antecedents } = json;
+    let { suppositions } = json;
 
-    const antecedentsJSON = antecedents;  ///
+    const suppositionsJSON = suppositions;  ///
 
-    antecedents = antecedentsJSON.map((antecedentJSON) => {
-      const json = antecedentJSON, ///
-            antecedent = Antecedent.fromJSON(json, releaseContext);
+    suppositions = suppositionsJSON.map((suppositionJSON) => {
+      const json = suppositionJSON, ///
+            supposition = Supposition.fromJSON(json, releaseContext);
 
-      return antecedent;
+      return supposition;
     });
 
-    let { consequent } = json;
+    let { consequence } = json;
 
-    const consequentJSON = consequent;  ///
+    const consequenceJSON = consequence;  ///
 
-    json = consequentJSON;  ///
+    json = consequenceJSON;  ///
 
-    consequent = Consequent.fromJSON(json, releaseContext);
+    consequence = Consequence.fromJSON(json, releaseContext);
 
-    return new Class(labels, antecedents, consequent);  ///
+    return new Class(labels, suppositions, consequence);  ///
   }
 
-  static fromLabelsAntecedentsAndConsequent(Class, labels, antecedents, consequent) { return new Class(labels, antecedents, consequent); }
+  static fromLabelsSuppositionsAndConsequence(Class, labels, suppositions, consequence) { return new Class(labels, suppositions, consequence); }
 }
 
-function matchAntecedent(antecedent, proofSteps, substitutions) {
+function matchSupposition(supposition, proofSteps, substitutions) {
   const proofStep = prune(proofSteps, (proofStep) => {
     const subproofNode = proofStep.getSubproofNode(),
           statementNode = proofStep.getStatementNode();
 
     if (subproofNode !== null) {
-      const subProofMatches = antecedent.matchSubproofNode(subproofNode, substitutions);
+      const subProofMatches = supposition.matchSubproofNode(subproofNode, substitutions);
 
       if (!subProofMatches) {  ///
         return true;
@@ -141,7 +141,7 @@ function matchAntecedent(antecedent, proofSteps, substitutions) {
     }
 
     if (statementNode !== null) {
-      const statementMatches = antecedent.matchStatementNode(statementNode, substitutions);
+      const statementMatches = supposition.matchStatementNode(statementNode, substitutions);
 
       if (!statementMatches) {  ///
         return true;
@@ -150,41 +150,41 @@ function matchAntecedent(antecedent, proofSteps, substitutions) {
 
   }) || null;
 
-  const antecedentMatches = (proofStep !== null);
+  const suppositionMatches = (proofStep !== null);
 
-  return antecedentMatches;
+  return suppositionMatches;
 }
 
-function matchAntecedents(antecedent, proofSteps, substitutions) {
-  const antecedentsMatches = antecedent.every((antecedent) => {
-    const antecedentMatches = matchAntecedent(antecedent, proofSteps, substitutions);
+function matchSuppositions(supposition, proofSteps, substitutions) {
+  const suppositionsMatches = supposition.every((supposition) => {
+    const suppositionMatches = matchSupposition(supposition, proofSteps, substitutions);
 
-    if (antecedentMatches) {
+    if (suppositionMatches) {
       return true;
     }
   });
 
-  return antecedentsMatches;
+  return suppositionsMatches;
 }
 
-function matchConsequent(consequent, statementNode, substitutions) {
-  const nonTerminalNodeMatches = consequent.matchStatementNode(statementNode, substitutions),
-        consequentMatches = nonTerminalNodeMatches; ///
+function matchConsequence(consequence, statementNode, substitutions) {
+  const nonTerminalNodeMatches = consequence.matchStatementNode(statementNode, substitutions),
+        consequenceMatches = nonTerminalNodeMatches; ///
 
-  return consequentMatches;
+  return consequenceMatches;
 }
 
-function matchAntecedentsAndConsequent(antecedents, consequent, proofSteps, statementNode) {
-  let antecedentsMatchConsequent = false;
+function matchSuppositionsAndConsequence(suppositions, consequence, proofSteps, statementNode) {
+  let suppositionsMatchConsequence = false;
 
   const substitutions = [],
-        antecedentsMatches = matchAntecedents(antecedents, proofSteps, substitutions);
+        suppositionsMatches = matchSuppositions(suppositions, proofSteps, substitutions);
 
-  if (antecedentsMatches) {
-    const consequentMatches = matchConsequent(consequent, statementNode, substitutions);
+  if (suppositionsMatches) {
+    const consequenceMatches = matchConsequence(consequence, statementNode, substitutions);
 
-    antecedentsMatchConsequent = consequentMatches;  ///
+    suppositionsMatchConsequence = consequenceMatches;  ///
   }
 
-  return antecedentsMatchConsequent;
+  return suppositionsMatchConsequence;
 }

package/src/consequence.js

@@ -0,0 +1,187 @@
+"use strict";
+
+import { first } from "./utilities/array";
+import { nodeAsString } from "./utilities/string";
+import { variableNameFromVariableNode } from "./utilities/query";
+import { statementNodeFromStatementString } from "./utilities/string";
+import { VARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "./ruleNames";
+
+export default class Consequence {
+  constructor(statementNode) {
+    this.statementNode = statementNode;
+  }
+
+  getStatementNode() {
+    return this.statementNode;
+  }
+
+  matchStatementNode(statementNode, metaSubstitutions) {
+    const nonTerminalNode = statementNode,  ///
+          consequenceNonTerminalNode = this.statementNode,  ///
+          consequenceNonTerminalNodeMatches = matchConsequenceNonTerminalNode(consequenceNonTerminalNode, nonTerminalNode, metaSubstitutions),
+          statementNodeMatches = consequenceNonTerminalNodeMatches; ///
+
+    return statementNodeMatches;
+  }
+
+  toJSON() {
+    const statementString = nodeAsString(this.statementNode),
+          statement = statementString,  ///
+          json = {
+            statement
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, releaseContext) {
+    const { statement } = json,
+          statementString = statement,  ///
+          statementNode = statementNodeFromStatementString(statementString, releaseContext),
+          consequence = new Consequence(statementNode);
+
+    return consequence;
+  }
+
+  static fromStatementNode(statementNode) {
+    const consequence = new Consequence(statementNode);
+
+    return consequence;
+  }
+}
+
+function matchConsequenceNode(consequenceNode, node, metaSubstitutions) {
+  let consequenceNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = consequenceNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            consequenceTerminalNode = consequenceNode,  ///
+            consequenceTerminalNodeMatches = matchConsequenceTerminalNode(consequenceTerminalNode, terminalNode, metaSubstitutions);
+
+      consequenceNodeMatches = consequenceTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            consequenceNonTerminalNode = consequenceNode,  ///
+            consequenceNonTerminalNodeMatches = matchConsequenceNonTerminalNode(consequenceNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+      consequenceNodeMatches = consequenceNonTerminalNodeMatches; ///
+    }
+  }
+
+  return consequenceNodeMatches;
+}
+
+function matchConsequenceNodes(consequenceNodes, nodes, metaSubstitutions) {
+  let consequenceNodesMatches = false;
+
+  const nodesLength = nodes.length,
+        consequenceNodesLength = consequenceNodes.length;
+
+  if (nodesLength === consequenceNodesLength) {
+    consequenceNodesMatches = nodes.every((node, index) => {
+      const consequenceNode = consequenceNodes[index],
+            consequenceNodeMatches = matchConsequenceNode(consequenceNode, node, metaSubstitutions);
+
+      if (consequenceNodeMatches) {
+        return true;
+      }
+    });
+  }
+
+  return consequenceNodesMatches;
+}
+
+function matchConsequenceVariable(consequenceVariableNode, nodes, metaSubstitutions) {
+  let consequenceVariableMatches = true;
+
+  const consequenceVariableName = variableNameFromVariableNode(consequenceVariableNode),
+        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
+          const variableName = metaSubstitution.getVariableName();
+
+          if (variableName === consequenceVariableName) {
+            return true;
+          }
+        }) || null;
+
+  if (metaSubstitution !== null) {
+    const metaSubstitutionNodesMatch = metaSubstitution.matchNodes(nodes);
+
+    consequenceVariableMatches = metaSubstitutionNodesMatch;  ///
+  }
+
+  return consequenceVariableMatches;
+}
+
+function matchConsequenceTerminalNode(consequenceTerminalNode, terminalNode, metaSubstitutions) {
+  const matches = consequenceTerminalNode.match(terminalNode),
+        consequenceTerminalNodeMatches = matches;  ///
+
+  return consequenceTerminalNodeMatches;
+}
+
+function matchConsequenceNonTerminalNode(consequenceNonTerminalNode, nonTerminalNode, metaSubstitutions) {
+  let consequenceNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        consequenceRuleName = consequenceNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === consequenceRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          consequenceChildNodes = consequenceNonTerminalNode.getChildNodes(),
+          nodes = childNodes, ///
+          consequenceNodes = consequenceChildNodes, ///
+          consequenceChildNodesMatches = matchConsequenceNodes(consequenceNodes, nodes, metaSubstitutions);
+
+    consequenceNonTerminalNodeMatches = consequenceChildNodesMatches; ///
+
+    if (!consequenceNonTerminalNodeMatches) {
+      const ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME);
+
+      if (ruleNameStatementRuleName) {
+        const statementNode = nonTerminalNode,  ///
+              consequenceStatementNode = consequenceNonTerminalNode,  ///
+              consequenceStatementNodeMatches = matchConsequenceStatementNode(consequenceStatementNode, statementNode, metaSubstitutions);
+
+        consequenceNonTerminalNodeMatches = consequenceStatementNodeMatches; ///
+      }
+    }
+  }
+
+  return consequenceNonTerminalNodeMatches;
+}
+
+function matchConsequenceStatementNode(consequenceStatementNode, statementNode, metaSubstitutions) {
+  let consequenceStatementNodeMatches = false;
+
+  const consequenceNonTerminalNode = consequenceStatementNode,  ///
+        consequenceChildNodes = consequenceNonTerminalNode.getChildNodes(),
+        consequenceChildNodesLength = consequenceChildNodes.length;
+
+  if (consequenceChildNodesLength === 1) {
+    const firstConsequenceChildNode = first(consequenceChildNodes),
+          consequenceChildNode = firstConsequenceChildNode,  ///
+          consequenceChildNodeNonTerminalNode = consequenceChildNode.isNonTerminalNode();
+
+    if (consequenceChildNodeNonTerminalNode) {
+      const consequenceNonTerminalChildNode = consequenceChildNode,  ///
+            consequenceNonTerminalChildNodeRuleName = consequenceNonTerminalChildNode.getRuleName(),
+            consequenceNonTerminalChildNodeRuleNameVariableRuleName = (consequenceNonTerminalChildNodeRuleName === VARIABLE_RULE_NAME);
+
+      if (consequenceNonTerminalChildNodeRuleNameVariableRuleName) {
+        const consequenceVariableNode = consequenceNonTerminalChildNode,  ///
+              nonTerminalNode = statementNode,  ///
+              childNodes = nonTerminalNode.getChildNodes(),
+              nodes = childNodes, ///
+              consequenceMetaVariableMatches = matchConsequenceVariable(consequenceVariableNode, nodes, metaSubstitutions);
+
+        consequenceStatementNodeMatches = consequenceMetaVariableMatches; ///
+      }
+    }
+  }
+
+  return consequenceStatementNodeMatches;
+}

package/src/lemma.js

@@ -9,5 +9,5 @@ export default class Lemma extends AxiomLemmaTheorem {
 
   static fromJSON(json, releaseContext) { return AxiomLemmaTheorem.fromJSON(Lemma, json, releaseContext); }
 
-  static fromLabelsAntecedentsAndConsequent(labels, antecedents, consequent) { return AxiomLemmaTheorem.fromLabelsAntecedentsAndConsequent(Lemma, labels, antecedents, consequent); }
+  static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheorem.fromLabelsSuppositionsAndConsequence(Lemma, labels, suppositions, consequence); }
 }

package/src/metaSupposition.js

@@ -0,0 +1,235 @@
+"use strict";
+
+import MetaSubstitution from "./metaSubstitution";
+
+import { first } from "./utilities/array";
+import { nodeAsString } from "./utilities/string";
+import { nodeQuery, nodesQuery } from "./utilities/query";
+import { metavariableNameFromMetavariableNode } from "./utilities/query";
+import { metastatementNodeFromMetastatementString } from "./utilities/string";
+import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "./ruleNames";
+
+const metastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
+      metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion!"),
+      unqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/metaSubproof/unqualifiedMetastatement/metastatement!"),
+      qualifiedOrUnqualifiedMetastatementMetastatementNodeQuery = nodeQuery("/metaSubproof/subDerivation/qualifiedMetastatement|unqualifiedMetastatement[-1]/metastatement!");
+
+export default class MetaSupposition {
+  constructor(metastatementNode) {
+    this.metastatementNode = metastatementNode;
+  }
+
+  getMetastatementNode() {
+    return this.metastatementNode;
+  }
+
+  matchSubproofNode(metaSubproofNode, metaSubstitutions) {
+    let metaSubproofNodeMatches = false;
+
+    const metaSubproofAssertionNode = metaSubproofAssertionNodeQuery(this.metastatementNode);
+
+    if (metaSubproofAssertionNode !== null) {
+      const metaSubproofAssertionMetastatementNodes = metastatementNodesQuery(metaSubproofAssertionNode),
+            unqualifiedMetastatementMetastatementNodes = unqualifiedMetastatementMetastatementNodesQuery(metaSubproofNode),
+            qualifiedOrUnqualifiedMetastatementMetastatementNode = qualifiedOrUnqualifiedMetastatementMetastatementNodeQuery(metaSubproofNode),
+            metastatementNodes = [
+              ...unqualifiedMetastatementMetastatementNodes,
+              qualifiedOrUnqualifiedMetastatementMetastatementNode
+            ],
+            metastatementNodesLength = metastatementNodes.length,
+            metaSubproofAssertionMetastatementNodesLength = metaSubproofAssertionMetastatementNodes.length;
+
+      if (metastatementNodesLength === metaSubproofAssertionMetastatementNodesLength) {
+        metaSubproofNodeMatches = metaSubproofAssertionMetastatementNodes.every((metaSubproofAssertionMetastatementNode, index) => {
+                                    const metastatementNode = metastatementNodes[index],
+                                          nonTerminalNode = metastatementNode, ///
+                                          metaSuppositionNonTerminalNode = metaSubproofAssertionMetastatementNode,  ///
+                                          metaSuppositionNonTerminalNodeMatches = matchMetaSuppositionNonTerminalNode(metaSuppositionNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+                                    if (metaSuppositionNonTerminalNodeMatches) {
+                                      return true;
+                                    }
+                                  });
+      }
+    }
+
+    return metaSubproofNodeMatches;
+  }
+
+  matchMetastatementNode(metastatementNode, metaSubstitutions) {
+    const nonTerminalNode = metastatementNode,  ///
+          metaSuppositionNonTerminalNode = this.metastatementNode,  ///
+          metaSuppositionNonTerminalNodeMatches = matchMetaSuppositionNonTerminalNode(metaSuppositionNonTerminalNode, nonTerminalNode, metaSubstitutions),
+          metastatementNodeMatches = metaSuppositionNonTerminalNodeMatches; ///
+
+    return metastatementNodeMatches;
+  }
+
+  toJSON() {
+    const metastatementString = nodeAsString(this.metastatementNode),
+          metastatement = metastatementString, ///
+          json = {
+            metastatement
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, releaseContext) {
+    const { metastatement } = json,
+          metastatementString = metastatement,  ///
+          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, releaseContext),
+          metaSupposition = new MetaSupposition(metastatementNode);
+
+    return metaSupposition;
+  }
+
+  static fromMetastatementNode(metastatementNode) {
+    const metaSupposition = new MetaSupposition(metastatementNode);
+
+    return metaSupposition;
+  }
+}
+
+function matchMetaSuppositionNode(metaSuppositionNode, node, metaSubstitutions) {
+  let metaSuppositionNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = metaSuppositionNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            metaSuppositionTerminalNode = metaSuppositionNode,  ///
+            metaSuppositionTerminalNodeMatches = matchMetaSuppositionTerminalNode(metaSuppositionTerminalNode, terminalNode, metaSubstitutions);
+
+      metaSuppositionNodeMatches = metaSuppositionTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            metaSuppositionNonTerminalNode = metaSuppositionNode,  ///
+            metaSuppositionNonTerminalNodeMatches = matchMetaSuppositionNonTerminalNode(metaSuppositionNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+      metaSuppositionNodeMatches = metaSuppositionNonTerminalNodeMatches; ///
+    }
+  }
+
+  return metaSuppositionNodeMatches;
+}
+
+function matchMetaSuppositionNodes(metaSuppositionNodes, nodes, metaSubstitutions) {
+  let metaSuppositionNodesMatches = false;
+
+  const nodesLength = nodes.length,
+        metaSuppositionNodesLength = metaSuppositionNodes.length;
+
+  if (nodesLength === metaSuppositionNodesLength) {
+    metaSuppositionNodesMatches = nodes.every((node, index) => {
+      const metaSuppositionNode = metaSuppositionNodes[index],
+            metaSuppositionNodeMatches = matchMetaSuppositionNode(metaSuppositionNode, node, metaSubstitutions);
+
+      if (metaSuppositionNodeMatches) {
+        return true;
+      }
+    });
+  }
+
+  return metaSuppositionNodesMatches;
+}
+
+function matchMetaSuppositionMetavariable(metaSuppositionMetavariableNode, nodes, metaSubstitutions) {
+  let metaSuppositionMetavariableMatches;
+
+  const metaSuppositionMetavariableName = metavariableNameFromMetavariableNode(metaSuppositionMetavariableNode),
+        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
+          const metavariableName = metaSubstitution.getMetavariableName();
+
+          if (metavariableName === metaSuppositionMetavariableName) {
+            return true;
+          }
+        }) || null;
+
+  if (metaSubstitution !== null) {
+    const metaSubstitutionNodesMatch = metaSubstitution.matchNodes(nodes);
+
+    metaSuppositionMetavariableMatches = metaSubstitutionNodesMatch;  ///
+  } else {
+    const metavariableName = metaSuppositionMetavariableName, ///
+          metaSubstitution = MetaSubstitution.fromMetavariableNameAndNodes(metavariableName, nodes);
+
+    metaSubstitutions.push(metaSubstitution);
+
+    metaSuppositionMetavariableMatches = true;
+  }
+
+  return metaSuppositionMetavariableMatches;
+}
+
+function matchMetaSuppositionTerminalNode(metaSuppositionTerminalNode, terminalNode, metaSubstitutions) {
+  const matches = metaSuppositionTerminalNode.match(terminalNode),
+        metaSuppositionTerminalNodeMatches = matches;
+
+  return metaSuppositionTerminalNodeMatches;
+}
+
+function matchMetaSuppositionNonTerminalNode(metaSuppositionNonTerminalNode, nonTerminalNode, metaSubstitutions) {
+  let metaSuppositionNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        metaSuppositionRuleName = metaSuppositionNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === metaSuppositionRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          metaSuppositionChildNodes = metaSuppositionNonTerminalNode.getChildNodes(),
+          nodes = childNodes, ///
+          metaSuppositionNodes = metaSuppositionChildNodes, ///
+          metaSuppositionChildNodesMatches = matchMetaSuppositionNodes(metaSuppositionNodes, nodes, metaSubstitutions);
+
+    metaSuppositionNonTerminalNodeMatches = metaSuppositionChildNodesMatches; ///
+
+    if (!metaSuppositionNonTerminalNodeMatches) {
+      const ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME);
+
+      if (ruleNameMetastatementRuleName) {
+        const metastatementNode = nonTerminalNode,  ///
+              metaSuppositionMetastatementNode = metaSuppositionNonTerminalNode,  ///
+              metaSuppositionMetastatementNodeMatches = matchMetaSuppositionMetastatementNode(metaSuppositionMetastatementNode, metastatementNode, metaSubstitutions);
+
+        metaSuppositionNonTerminalNodeMatches = metaSuppositionMetastatementNodeMatches; ///
+      }
+    }
+  }
+
+  return metaSuppositionNonTerminalNodeMatches;
+}
+
+function matchMetaSuppositionMetastatementNode(metaSuppositionMetastatementNode, metastatementNode, metaSubstitutions) {
+  let metaSuppositionMetastatementNodeMatches = false;
+
+  const metaSuppositionNonTerminalNode = metaSuppositionMetastatementNode,  ///
+        metaSuppositionChildNodes = metaSuppositionNonTerminalNode.getChildNodes(),
+        metaSuppositionChildNodesLength = metaSuppositionChildNodes.length;
+
+  if (metaSuppositionChildNodesLength === 1) {
+    const firstMetaSuppositionChildNode = first(metaSuppositionChildNodes),
+          metaSuppositionChildNode = firstMetaSuppositionChildNode,  ///
+          metaSuppositionChildNodeNonTerminalNode = metaSuppositionChildNode.isNonTerminalNode();
+
+    if (metaSuppositionChildNodeNonTerminalNode) {
+      const metaSuppositionNonTerminalChildNode = metaSuppositionChildNode,  ///
+            metaSuppositionNonTerminalChildNodeRuleName = metaSuppositionNonTerminalChildNode.getRuleName(),
+            metaSuppositionNonTerminalChildNodeRuleNameMetavariableRuleName = (metaSuppositionNonTerminalChildNodeRuleName === METAVARIABLE_RULE_NAME);
+
+      if (metaSuppositionNonTerminalChildNodeRuleNameMetavariableRuleName) {
+        const metaSuppositionMetavariableNode = metaSuppositionNonTerminalChildNode,  ///
+              nonTerminalNode = metastatementNode,  ///
+              childNodes = nonTerminalNode.getChildNodes(),
+              nodes = childNodes, ///
+              metaSuppositionMetavariableMatches = matchMetaSuppositionMetavariable(metaSuppositionMetavariableNode, nodes, metaSubstitutions);
+
+        metaSuppositionMetastatementNodeMatches = metaSuppositionMetavariableMatches; ///
+      }
+    }
+  }
+
+  return metaSuppositionMetastatementNodeMatches;
+}