occam-verify-cli 0.0.270 → 0.0.272

package/bin/verify/axiom/IndicativeConditional.js

@@ -2,7 +2,7 @@
 
 const Axiom = require("../../axiom"),
       verifyLabels = require("../../verify/labels"),
-      verifyAntecedent = require("../../verify/antecedent"),
+      verifySupposition = require("../../verify/antecedent"),
       verifyConsequent = require("../../verify/consequent");
 
 const { first } = require("../../utilities/array"),
@@ -26,7 +26,7 @@ function verifyIndicativeConditionalAxiom(axiomNode, context) {
     if (labelsVerified) {
       const antecedents = [],
             antecedentNode = antecedentNodeQuery(indicativeConditionalNode),
-            antecedentVerified = verifyAntecedent(antecedentNode, antecedents, context);
+            antecedentVerified = verifySupposition(antecedentNode, antecedents, context);
 
       if (antecedentVerified) {
         const consequents = [],
@@ -34,11 +34,11 @@ function verifyIndicativeConditionalAxiom(axiomNode, context) {
               consequentVerified = verifyConsequent(consequentNode, consequents, context);
 
         if (consequentVerified) {
-          const firstAntecedent = first(antecedents),
+          const firstSupposition = first(antecedents),
                 firstConsequent = first(consequents),
-                antecedent = firstAntecedent, ///
+                antecedent = firstSupposition, ///
                 consequent = firstConsequent, ///
-                axiom = Axiom.fromAntecedentConsequentAndLabels(antecedent, consequent, labels);
+                axiom = Axiom.fromSuppositionConsequentAndLabels(antecedent, consequent, labels);
 
           context.addAxiom(axiom);
 

package/bin/verify/conditinalInference.js

@@ -6,9 +6,10 @@ const verifyMetaproof = require("../verify/metaproof"),
       verifyPremiseOrPremises = require("../verify/premiseOrPremises");
 
 const { nodeQuery } = require("../utilities/query");
+const Conclusion = require("../conclusion");
 
-const metaproofNodeQuery = nodeQuery("/conditionalInference/metaproof!"),
-      conclusionNodeQuery = nodeQuery("/conditionalInference/conclusion!"),
+const conclusionNodeQuery = nodeQuery("/conditionalInference/conclusion!"),
+      metastatementNodeQuery = nodeQuery("/conditionalInference/conclusion!/unqualifiedMetastatement!/metastatement!"),
       premiseOrPremisesNodeQuery = nodeQuery("/conditionalInference/premise|premises!");
 
 function verifyConditionalInference(conditionalInferenceNode, premises, conclusions, context) {
@@ -18,23 +19,20 @@ function verifyConditionalInference(conditionalInferenceNode, premises, conclusi
 
   context = metaproofContext; ///
 
-  const premiseOrPremisesNode = premiseOrPremisesNodeQuery(conditionalInferenceNode),
+  const conclusionNode = conclusionNodeQuery(conditionalInferenceNode),
+        metastatementNode = metastatementNodeQuery(conditionalInferenceNode),
+        premiseOrPremisesNode = premiseOrPremisesNodeQuery(conditionalInferenceNode),
         premiseOrPremisesVerified = verifyPremiseOrPremises(premiseOrPremisesNode, premises, context);
 
   if (premiseOrPremisesVerified) {
-    const conclusionNode = conclusionNodeQuery(conditionalInferenceNode),
-          conclusionVerified = verifyConclusion(conclusionNode, conclusions, context);
+    const conclusionVerified = verifyConclusion(conclusionNode, conclusions, context);
 
     if (conclusionVerified) {
-      let metaproofVerified = true;
+      const conclusion = Conclusion.fromMetastatementNode(metastatementNode);
 
-      const metaproofNode = metaproofNodeQuery(conditionalInferenceNode);
+      conclusions.push(conclusion);
 
-      if (metaproofNode !== null) {
-        metaproofVerified = verifyMetaproof(metaproofNode, context);
-      }
-
-      conditionalInferenceVerified = metaproofVerified; ///
+      conditionalInferenceVerified = true;
     }
   }
 

package/bin/verify/metaDerivation.js

@@ -2,14 +2,14 @@
 
 const MetaAssertion = require("../metaAssertion"),
       MetaproofContext = require("../context/metaproof"),
-      verifyMetaAntecedent = require("../verify/metaAntecedent"),
+      verifyMetaSupposition = require("../verify/metaSupposition"),
       verifyQualifiedMetastatement = require("../verify/metastatement/qualified"),
       verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
 const { nodeQuery, nodesQuery } = require("../utilities/query"),
       { META_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } = require("../ruleNames");
 
-const metaAntecedentNodeQuery = nodeQuery("/metaSubproof/metaAntecedent!"),
+const metaSuppositionNodeQuery = nodeQuery("/metaSubproof/metaSupposition!"),
       metaDerivationNodeQuery = nodeQuery("/metaSubproof/metaDerivation!"),
       metaDerivationChildNodesQuery = nodesQuery("/metaDerivation/*"),
       qualifiedMetastatementNodeQuery = nodeQuery("/metaSubproof/qualifiedMetastatement!"),
@@ -89,10 +89,10 @@ function verifyMetaSubproof(metaSubproofNode, context) {
 
   context = metaproofContext; ///
 
-  const metaAntecedentNode = metaAntecedentNodeQuery(metaSubproofNode),
-        metaAntecedentVerified = verifyMetaAntecedent(metaAntecedentNode, context);
+  const metaSuppositionNode = metaSuppositionNodeQuery(metaSubproofNode),
+        metaSuppositionVerified = verifyMetaSupposition(metaSuppositionNode, context);
 
-  if (metaAntecedentVerified) {
+  if (metaSuppositionVerified) {
     let metaDerivationVerified = true;
 
     const metaDerivationNode = metaDerivationNodeQuery(metaSubproofNode);

package/bin/verify/metaSupposition.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const MetaAssertion = require("../metaAssertion"),
+      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
+
+const { nodeQuery } = require("../utilities/query");
+
+const unqualifiedMetastatementNodeQuery = nodeQuery("/metaSupposition/unqualifiedMetastatement!");
+
+function verifyMetaSupposition(metaSuppositionNode, context) {
+  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSuppositionNode),
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context),
+        metaSuppositionVerified = unqualifiedMetastatementVerified;  ///
+
+  if (metaSuppositionVerified) {
+    const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
+
+    context.addMetaAssertion(metaAssertion);
+  }
+
+  return metaSuppositionVerified;
+}
+
+module.exports = verifyMetaSupposition;

package/bin/verify/metaproof.js

@@ -5,16 +5,16 @@ const verifyMetaDerivation = require("../verify/metaDerivation"),
 
 const { nodeQuery } = require("../utilities/query");
 
-const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement!/metastatement!"),
-      metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!"),
-      qualifiedStatementNodeQuery = nodeQuery("/metaproof/qualifiedMetastatement!");
+const metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!"),
+      qualifiedStatementNodeQuery = nodeQuery("/metaproof/qualifiedMetastatement!"),
+      metaProofMetastatementNodeQuery = nodeQuery("/metaproof/qualifiedMetastatement/metastatement!");
 
-function verifyMetaproof(metaproofNode, context) {
+function verifyMetaproof(metaproofNode, metastatementNode, context) {
   let metaproofVerified = false;
 
   const metaDerivationNode = metaDerivationNodeQuery(metaproofNode);
 
-  let metaDerivationVerified = false;
+  let metaDerivationVerified = true;
 
   if (metaDerivationNode !== null) {
     metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, context);
@@ -25,18 +25,10 @@ function verifyMetaproof(metaproofNode, context) {
           qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
 
     if (qualifiedMetastatementVerified) {
-      debugger
-
-      // const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-      //       firstRule = first(rules),
-      //       rule = firstRule, ///
-      //       metastatementString = nodeAsString(metastatementNode),
-      //       conclusionMetastatementNode = rule.getConclusionMetastatementNode(),
-      //       conclusionMetastatementString = nodeAsString(conclusionMetastatementNode);
-      //
-      // if (metastatementString === conclusionMetastatementString) {
-      //   metaproofVerified = true;
-      // }
+      const metaProofMetastatementNode = metaProofMetastatementNodeQuery(metaproofNode),
+            metaProofMetastatementNodeMatches = matchMetaProofMetastatementNode(metaProofMetastatementNode, metastatementNode);
+
+      metaproofVerified = metaProofMetastatementNodeMatches;  ///
     }
   }
 
@@ -44,3 +36,83 @@ function verifyMetaproof(metaproofNode, context) {
 }
 
 module.exports = verifyMetaproof;
+
+function matchMetaProofMetastatementNode(metaProofMetastatementNode, metastatementNode) {
+  const metaProofNonTerminalNode = metaProofMetastatementNode,  ///
+        nonTerminalNode = metastatementNode,  ///
+        metaProofNonTerminalNodeMatches = matchMetaProofNonTerminalNode(metaProofNonTerminalNode, nonTerminalNode),
+        metaProofMetastatementNodeMatches = metaProofNonTerminalNodeMatches;  ///
+
+  return metaProofMetastatementNodeMatches;
+}
+
+function matchMetaProofNode(metaProofNode, node) {
+  let metaProofNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = metaProofNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            metaProofTerminalNode = metaProofNode,  ///
+            metaProofTerminalNodeMatches = matchMetaProofTerminalNode(metaProofTerminalNode, terminalNode);
+
+      metaProofNodeMatches = metaProofTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            metaProofNonTerminalNode = metaProofNode,  ///
+            metaProofNonTerminalNodeMatches = matchMetaProofNonTerminalNode(metaProofNonTerminalNode, nonTerminalNode);
+
+      metaProofNodeMatches = metaProofNonTerminalNodeMatches; ///
+    }
+  }
+
+  return metaProofNodeMatches;
+}
+
+function matchMetaProofNodes(metaProofNodes, nodes) {
+  let metaProofNodesMatches = false;
+
+  const nodesLength = nodes.length,
+        metaProofNodesLength = metaProofNodes.length;
+
+  if (nodesLength === metaProofNodesLength) {
+    metaProofNodesMatches = nodes.every((node, index) => {
+      const metaProofNode = metaProofNodes[index],
+            metaProofNodeMatches = matchMetaProofNode(metaProofNode, node);
+
+      if (metaProofNodeMatches) {
+        return true;
+      }
+    })
+  }
+
+  return metaProofNodesMatches;
+}
+
+function matchMetaProofTerminalNode(metaProofTerminalNode, terminalNode) {
+  const matches = metaProofTerminalNode.match(terminalNode),
+        metaProofTerminalNodeMatches = matches;  ///
+
+  return metaProofTerminalNodeMatches;
+}
+
+function matchMetaProofNonTerminalNode(metaProofNonTerminalNode, nonTerminalNode) {
+  let metaProofNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        metaProofRuleName = metaProofNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === metaProofRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          metaProofChildNodes = metaProofNonTerminalNode.getChildNodes(),
+          nodes = childNodes, ///
+          metaProofNodes = metaProofChildNodes, ///
+          metaProofNodesMatches = matchMetaProofNodes(metaProofNodes, nodes);
+
+    metaProofNonTerminalNodeMatches = metaProofNodesMatches; ///
+  }
+
+  return metaProofNonTerminalNodeMatches;
+}

package/bin/verify/metastatement/qualified.js

@@ -23,16 +23,14 @@ function verifyQualifiedMetastatement(qualifiedMetastatementNode, context) {
     if (rule !== null) {
       const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, context);
 
-      if (ruleMatchesMetastatement) {
-        qualifiedMetastatementVerified = true;
-      }
+      qualifiedMetastatementVerified = ruleMatchesMetastatement;  ///
     }
   }
 
   if (qualifiedMetastatementVerified) {
     const metastatementString = nodeAsString(metastatementNode);
 
-    log.info(`Verified the '${metastatementString}' qualified metastatement.`);
+    log.debug(`Verified the '${metastatementString}' qualified metastatement.`);
   }
 
   return qualifiedMetastatementVerified;

package/bin/verify/metastatement/unqualified.js

@@ -20,10 +20,10 @@ function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context) {
     const derived = context.isDerived();
 
     if (derived) {
-      const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode),
-            metaAssertionPresent = context.isMetaAssertionPresent(metaAssertion);
+      const metaAssertion = MetaAssertion.fromMetastatementNode(metastatementNode),
+            metaAssertionMatches = context.matchMetaAssertion(metaAssertion);
 
-      unqualifiedMetastatementVerified = metaAssertionPresent;  ///
+      unqualifiedMetastatementVerified = metaAssertionMatches;  ///
     } else {
       unqualifiedMetastatementVerified = true;
     }
@@ -32,7 +32,7 @@ function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context) {
   if (unqualifiedMetastatementVerified) {
     const metastatementString = nodeAsString(metastatementNode);
 
-    log.info(`Verified the '${metastatementString}' unqualified metastatement.`);
+    log.debug(`Verified the '${metastatementString}' unqualified metastatement.`);
   }
 
   return unqualifiedMetastatementVerified;

package/bin/verify/rule.js

@@ -4,6 +4,7 @@ const { loggingUtilities } = require("necessary");
 
 const Rule = require("../rule"),
       verifyLabels = require("../verify/labels"),
+      verifyMetaproof = require("../verify/metaproof"),
       verifyConditionalInference = require("../verify/conditinalInference"),
       verifyUnconditionalInference = require("../verify/unconditionalInference");
 
@@ -14,6 +15,7 @@ const { first } = require("../utilities/array"),
 const { log } = loggingUtilities;
 
 const labelNodesQuery = nodesQuery("/rule/label"),
+      metaproofNodeQuery = nodeQuery("/rule/metaproof!"),
       conditionalInferenceNodeQuery = nodeQuery("/rule/conditionalInference!"),
       unconditionalInferenceNodeQuery = nodeQuery("/rule/unconditionalInference!");
 
@@ -34,25 +36,40 @@ function verifyRule(ruleNode, context) {
           conditionalInferenceNode = conditionalInferenceNodeQuery(ruleNode),
           unconditionalInferenceNode = unconditionalInferenceNodeQuery(ruleNode);
 
-    if (conditionalInferenceNode !== null) {
-      const conditionalInferenceVerified = verifyConditionalInference(conditionalInferenceNode, premises, conclusions, context);
+    let conditionalInferenceVerified = false,
+        unconditionalInferenceVerified = false;
 
-      ruleVerified = conditionalInferenceVerified;  ///
+    if (conditionalInferenceNode !== null) {
+      conditionalInferenceVerified = verifyConditionalInference(conditionalInferenceNode, premises, conclusions, context);
     }
 
     if (unconditionalInferenceNode !== null) {
-      const unconditionalInferenceVerified = verifyUnconditionalInference(unconditionalInferenceNode, premises, conclusions, context);
-
-      ruleVerified = unconditionalInferenceVerified;  ///
+      unconditionalInferenceVerified = verifyUnconditionalInference(unconditionalInferenceNode, premises, conclusions, context);
     }
 
-    if (ruleVerified) {
-      const firstConclusion = first(conclusions),
-            conclusion = firstConclusion, ///
-            rule = Rule.fromPremisesConclusionAndLabels(premises, conclusion, labels);
+    if (conditionalInferenceVerified || unconditionalInferenceVerified) {
+      const metaproofNode = metaproofNodeQuery(ruleNode),
+            firstConclusion = first(conclusions),
+            conclusion = firstConclusion; ///
+
+      let metaproofVerified = true;
+
+      if (metaproofNode !== null) {
+        const metastatementNode = conclusion.getMetastatementNode();
 
-      context.addRule(rule);
+        metaproofVerified = verifyMetaproof(metaproofNode, metastatementNode, context);
+      }
 
+      if (metaproofVerified) {
+        const rule = Rule.fromPremisesConclusionAndLabels(premises, conclusion, labels);
+
+        context.addRule(rule);
+
+        ruleVerified = true;
+      }
+    }
+
+    if (ruleVerified) {
       log.info(`Verified the '${labelsString}' rule.`);
     }
   }

package/bin/verify/statement.js

@@ -3,7 +3,7 @@
 const { loggingUtilities } = require("necessary");
 
 const verifyEquality = require("../verify/equality"),
-      verifyTypeAssertion = require("../verify/typeAssertion");
+      verifyTypeAssertion = require("../verify/assertion/type");
 
 const { nodeQuery } = require("../utilities/query"),
       { nodeAsString } = require("../utilities/string");

package/bin/verify/supposition.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const Assertion = require("../assertion"),
+      verifyUnqualifiedStatement = require("../verify/statement/unqualified");
+
+const { nodeQuery } = require("../utilities/query");
+
+const unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement!");
+
+function verifySupposition(suppositionNode, suppositions, context) {
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
+        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context),
+        suppositionVerified = unqualifiedStatementVerified;
+
+  if (suppositionVerified) {
+    const supposition = Assertion.fromUnqualifiedStatementNode(unqualifiedStatementNode);
+
+    suppositions.push(supposition);
+  }
+
+  return suppositionVerified;
+}
+
+module.exports = verifySupposition;

package/bin/verify/unconditionalInference.js

@@ -1,14 +1,12 @@
 "use strict";
 
 const Conclusion = require("../conclusion"),
-      verifyMetaproof = require("../verify/metaproof"),
       MetaproofContext = require("../context/metaproof"),
       verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
 const { nodeQuery } = require("../utilities/query");
 
-const metaproofNodeQuery = nodeQuery("/unconditionalInference/metaproof!"),
-      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+const metastatementNodeQuery = nodeQuery("/unconditionalInference/unqualifiedMetastatement!/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/unconditionalInference/unqualifiedMetastatement!");
 
 function verifyUnconditionalInference(unconditionalInferenceNode, premises, conclusions, context) {
@@ -18,26 +16,16 @@ function verifyUnconditionalInference(unconditionalInferenceNode, premises, conc
 
   context = metaproofContext; ///
 
-  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(unconditionalInferenceNode),
+  const metastatementNode = metastatementNodeQuery(unconditionalInferenceNode),
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(unconditionalInferenceNode),
         unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
 
   if (unqualifiedMetastatementVerified) {
-    let metaproofVerified = true;
+    const conclusion = Conclusion.fromMetastatementNode(metastatementNode);
 
-    const metaproofNode = metaproofNodeQuery(unconditionalInferenceNode);
+    conclusions.push(conclusion);
 
-    if (metaproofNode !== null) {
-      metaproofVerified = verifyMetaproof(metaproofNode, context);
-    }
-
-    if (metaproofVerified) {
-      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-            conclusion = Conclusion.fromMetastatementNode(metastatementNode);
-
-      conclusions.push(conclusion);
-
-      unconditionalInferenceVerified = true;
-    }
+    unconditionalInferenceVerified = true;
   }
 
   return unconditionalInferenceVerified;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.270",
+  "version": "0.0.272",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,10 +12,10 @@
   "dependencies": {
     "argumentative": "^2.0.15",
     "necessary": "^11.0.40",
-    "occam-custom-grammars": "^5.0.351",
+    "occam-custom-grammars": "^5.0.353",
     "occam-dom": "^3.0.171",
     "occam-grammar-utilities": "^7.0.66",
-    "occam-grammars": "^1.0.318",
+    "occam-grammars": "^1.0.320",
     "occam-open-cli": "^5.0.37",
     "occam-parsers": "^16.0.122"
   },

package/bin/antecedent.js

@@ -1,19 +0,0 @@
-"use strict";
-
-class Antecedent {
-  constructor(statementNodes) {
-    this.statementNodes = statementNodes;
-  }
-
-  getStatementNodes() {
-    return this.statementNodes;
-  }
-
-  static fromStatementNodes(statementNodes) {
-    const antecedent = new Antecedent(statementNodes);
-
-    return antecedent;
-  }
-}
-
-module.exports = Antecedent;

package/bin/verify/antecedent.js

@@ -1,35 +0,0 @@
-"use strict";
-
-const Antecedent = require("../antecedent"),
-      verifyUnqualifiedStatement = require("../verify/statement/unqualified");
-
-const { nodeQuery, nodesQuery } = require("../utilities/query");
-
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement"),
-      unqualifiedStatementNodesQuery = nodesQuery("/antecedent/unqualifiedStatement");
-
-function verifyAntecedent(antecedentNode, antecedents, context) {
-  const unqualifiedStatementNodes = unqualifiedStatementNodesQuery(antecedentNode),
-        antecedentVerified = unqualifiedStatementNodes.every((unqualifiedStatementNode) => {
-          const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context);
-
-          if (unqualifiedStatementVerified) {
-            return true;
-          }
-        });
-
-  if (antecedentVerified) {
-    const statementNodes = unqualifiedStatementNodes.map((unqualifiedStatementNode) => {
-            const statementNode = statementNodeQuery(unqualifiedStatementNode);
-
-            return statementNode;
-          }),
-          antecedent = Antecedent.fromStatementNodes(statementNodes);
-
-    antecedents.push(antecedent);
-  }
-
-  return antecedentVerified;
-}
-
-module.exports = verifyAntecedent;

package/bin/verify/metaAntecedent.js

@@ -1,31 +0,0 @@
-"use strict";
-
-const MetaAssertion = require("../metaAssertion"),
-      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
-
-const { nodesQuery } = require("../utilities/query");
-
-const unqualifiedMetastatementNodesQuery = nodesQuery("/metaAntecedent/unqualifiedMetastatement");
-
-function verifyMetaAntecedent(metaAntecedentNode, context) {
-  const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(metaAntecedentNode),
-        metaAntecedentVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
-          const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
-
-          if (unqualifiedMetastatementVerified) {
-            return true;
-          }
-        });
-
-  if (metaAntecedentVerified) {
-    unqualifiedMetastatementNodes.forEach((unqualifiedMetastatementNode) => {
-      const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
-
-      context.addMetaAssertion(metaAssertion);
-    });
-  }
-
-  return metaAntecedentVerified;
-}
-
-module.exports = verifyMetaAntecedent;