occam-verify-cli 0.0.268 → 0.0.270

package/bin/context/file.js

@@ -186,6 +186,12 @@ class FileContext {
     return labelPresent;
   }
 
+  isMetaAssertionPresent(metaAssertion) {
+    const metaAssertionPresent = false;
+
+    return metaAssertionPresent;
+  }
+
   isTypePresentByTypeName(typeName) {
     const type = this.findTypeByTypeName(typeName),
           typePresent = (type !== null);
@@ -193,12 +199,6 @@ class FileContext {
     return typePresent;
   }
 
-  isMetastatementNodePresent(metaStatementNode) {
-    const metastatementNodePresent = false;
-
-    return metastatementNodePresent;
-  }
-
   isVariablePresentByVariableName(variableName) {
     const variable = this.findVariableByVariableName(variableName),
           variablePresent = (variable !== null);
@@ -230,10 +230,6 @@ class FileContext {
     this.constructors.push(constructor);
   }
 
-  setInAntecedent(inAntecedent) {
-    ///
-  }
-
   static fromPackageContextAndFilePath(packageContext, filePath) {
     const fileContent = packageContext.getFileContent(filePath),
           content = fileContent,  ///

package/bin/context/metaproof.js

@@ -1,12 +1,10 @@
 "use strict";
 
-const { nodeAsString } = require("../utilities/string");
-
 class MetaproofContext {
-  constructor(context, derived, metastatementNodes) {
+  constructor(context, derived, metaAssertions) {
     this.context = context;
     this.derived = derived;
-    this.metastatementNodes = metastatementNodes;
+    this.metaAssertions = metaAssertions;
   }
 
   getContext() {
@@ -17,8 +15,8 @@ class MetaproofContext {
     return this.derived;
   }
 
-  getMetastatementNodes() {
-    return this.metastatementNodes;
+  getMetaAssertions() {
+    return this.metaAssertions;
   }
 
   getRules() { return this.context.getRules(); }
@@ -41,47 +39,41 @@ class MetaproofContext {
 
   isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
 
-  isMetastatementNodePresent(metaStatementNode) {
-    const metastatementNodeA = metaStatementNode; ///
+  isMetaAssertionPresent(metaAssertion) {
+    const metaAssertionA = metaAssertion; ///
 
-    let metastatementNodePresent = this.metastatementNodes.some((metaStatementNode) => {
-      const metastatementNodeB = metaStatementNode, ///
-            metastatementNodeAString = nodeAsString(metastatementNodeA),
-            metastatementNodeBString = nodeAsString(metastatementNodeB),
-            matches = (metastatementNodeAString === metastatementNodeBString);
+    let metaAssertionPresent = this.metaAssertions.some((metaAssertion) => {
+      const metaAssertionB = metaAssertion, ///
+            matches = metaAssertionA.match(metaAssertionB);
 
       if (matches) {
         return true;
       }
     });
 
-    if (!metastatementNodePresent) {
-      metastatementNodePresent = this.context.isMetastatementNodePresent(metaStatementNode);
+    if (!metaAssertionPresent) {
+      metaAssertionPresent = this.context.isMetaAssertionPresent(metaAssertion);
     }
 
-    return metastatementNodePresent;
+    return metaAssertionPresent;
   }
 
   isVariablePresentByVariableName(variableName) { return this.context.isVariablePresentByVariableName(variableName); }
 
   setDerived(derived) {
-    if (derived) {
-      this.metastatementNodes.pop();
-    }
-
     this.derived = derived;
   }
 
   addRule(rule) { this.context.addRule(rule); }
 
-  addMetastatementNode(metastatementNode) {
-    this.metastatementNodes.push(metastatementNode);
+  addMetaAssertion(metaAssertion) {
+    this.metaAssertions.push(metaAssertion);
   }
 
   static fromContext(context) {
     const derived = false,
-          metastatementNodes = [],
-          metaproofContext = new MetaproofContext(context, derived, metastatementNodes);
+          metaAssertions = [],
+          metaproofContext = new MetaproofContext(context, derived, metaAssertions);
 
     return metaproofContext;
   }

package/bin/metaAssertion.js

@@ -0,0 +1,145 @@
+"use strict";
+
+const { nodeQuery } = require("./utilities/query");
+
+const metastatementNodeQuery = nodeQuery("/*/metastatement!");
+
+class MetaAssertion {
+  constructor(metaSubproofNode, metastatementNode) {
+    this.metaSubproofNode = metaSubproofNode;
+    this.metastatementNode = metastatementNode;
+  }
+
+  getNonTerminalNode() {
+    const nonTerminalNode = (this.metastatementNode !== null) ?
+                               this.metastatementNode :
+                                 null;
+
+    return nonTerminalNode;
+  }
+
+  getMetaSubproofNode() {
+    return this.metaSubproofNode;
+  }
+
+  getMetastatementNode() {
+    return this.metastatementNode;
+  }
+
+  match(metaAssertion) {
+    let matches = false;
+
+    const metastatementNode = metaAssertion.getMetastatementNode();
+
+    if ((metastatementNode !== null) && (this.metastatementNode !== null)) {
+      const nonTerminalNode = this.metastatementNode, ///
+            metaAssertionNonTerminalNode = metastatementNode, ///
+            metaAssertionNonTerminalNodeMatches = matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode);
+
+      matches = metaAssertionNonTerminalNodeMatches;  ///
+    }
+
+    return matches;
+  }
+
+  static fromMetaSubproofNode(metaSubproofNode) {
+    const metastatementNode = null,
+          metaAssertion = new MetaAssertion(metaSubproofNode, metastatementNode);
+
+    return metaAssertion;
+  }
+
+  static fromQualifiedMetastatementNode(qualifiedMetastatementNode) {
+    const metaSubproofNode = null,
+          metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+          metaAssertion = new MetaAssertion(metaSubproofNode, metastatementNode);
+
+    return metaAssertion;
+  }
+
+  static fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode) {
+    const metaSubproofNode = null,
+          metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+          metaAssertion = new MetaAssertion(metaSubproofNode, metastatementNode);
+
+    return metaAssertion;
+  }
+}
+
+module.exports = MetaAssertion;
+
+function matchMetaAssertionNode(metaAssertionNode, node) {
+  let metaAssertionNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = metaAssertionNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            metaAssertionTerminalNode = metaAssertionNode,  ///
+            metaAssertionTerminalNodeMatches = matchMetaAssertionTerminalNode(metaAssertionTerminalNode, terminalNode);
+
+      metaAssertionNodeMatches = metaAssertionTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            metaAssertionNonTerminalNode = metaAssertionNode,  ///
+            metaAssertionNonTerminalNodeMatches = matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode);
+
+      metaAssertionNodeMatches = metaAssertionNonTerminalNodeMatches; ///
+    }
+  }
+
+  return metaAssertionNodeMatches;
+}
+
+function matchMetaAssertionChildNodes(metaAssertionChildNodes, childNodes) {
+  let metaAssertionChildNodesMatches = false;
+
+  const childNodesLength = childNodes.length,
+      metaAssertionChildNodesLength = metaAssertionChildNodes.length;
+
+  if (childNodesLength === metaAssertionChildNodesLength) {
+    metaAssertionChildNodesMatches = childNodes.every((childNode, index) => {
+      const metaAssertionChildNode = metaAssertionChildNodes[index],
+            metaAssertionNode = metaAssertionChildNode, ///
+            node = childNode, ///
+            metaAssertionNodeMatches = matchMetaAssertionNode(metaAssertionNode, node);
+
+      if (metaAssertionNodeMatches) {
+        return true;
+      }
+    })
+  }
+
+  return metaAssertionChildNodesMatches;
+}
+
+function matchMetaAssertionTerminalNode(metaAssertionTerminalNode, terminalNode) {
+  let metaAssertionTerminalNodeMatches = false;
+
+  const matches = metaAssertionTerminalNode.match(terminalNode);
+
+  if (matches) {
+    metaAssertionTerminalNodeMatches = true;
+  }
+
+  return metaAssertionTerminalNodeMatches;
+}
+
+function matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode) {
+  let metaAssertionNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        metaAssertionRuleName = metaAssertionNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === metaAssertionRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          metaAssertionChildNodes = metaAssertionNonTerminalNode.getChildNodes(),
+          metaAssertionChildNodesMatches = matchMetaAssertionChildNodes(metaAssertionChildNodes, childNodes);
+
+    metaAssertionNonTerminalNodeMatches = metaAssertionChildNodesMatches; ///
+  }
+
+  return metaAssertionNonTerminalNodeMatches;
+}

package/bin/rule.js

@@ -23,15 +23,15 @@ class Rule {
   }
 
   matchMetastatement(metastatementNode, context) {
-    let metastatementNodes = context.getMetastatementNodes();
+    let metaAssertions = context.getMetaAssertions();
 
     const premisesLength = this.premises.length,
           start = -premisesLength;
 
-    metastatementNodes = metastatementNodes.slice(start); ///
+    metaAssertions = metaAssertions.slice(start); ///
 
-    const matchesMetastatement = someCombination(metastatementNodes, (metastatementNodes) => {
-      const premisesMatchConclusion = matchPremisesAndConclusion(this.premises, this.conclusion, metastatementNodes, metastatementNode);
+    const matchesMetastatement = someCombination(metaAssertions, (metaAssertions) => {
+      const premisesMatchConclusion = matchPremisesAndConclusion(this.premises, this.conclusion, metaAssertions, metastatementNode);
 
       if (premisesMatchConclusion) {
         return true;
@@ -56,24 +56,27 @@ class Rule {
 
 module.exports = Rule;
 
-function matchPremise(premise, metastatementNodes, metaSubstitutions) {
-  const metastatementNode = prune(metastatementNodes, (metastatementNode) => {
-    const nonTerminalNode = metastatementNode,  ///
-          nonTerminalNodeMatches = premise.matchNonTerminalNode(nonTerminalNode, metaSubstitutions);
+function matchPremise(premise, metaAssertions, metaSubstitutions) {
+  const metaAssertion = prune(metaAssertions, (metaAssertion) => {
+    const nonTerminalNode = metaAssertion.getNonTerminalNode();
 
-    if (!nonTerminalNodeMatches) {  ///
-      return true;
+    if (nonTerminalNode !== null) {
+      const nonTerminalNodeMatches = premise.matchNonTerminalNode(nonTerminalNode, metaSubstitutions);
+
+      if (!nonTerminalNodeMatches) {  ///
+        return true;
+      }
     }
   }) || null;
 
-  const premiseMatches = (metastatementNode !== null);
+  const premiseMatches = (metaAssertion !== null);
 
   return premiseMatches;
 }
 
-function matchPremises(premise, metastatementNodes, metaSubstitutions) {
+function matchPremises(premise, metaAssertions, metaSubstitutions) {
   const premisesMatches = premise.every((premise) => {
-    const premiseMatches = matchPremise(premise, metastatementNodes, metaSubstitutions);
+    const premiseMatches = matchPremise(premise, metaAssertions, metaSubstitutions);
 
     if (premiseMatches) {
       return true;
@@ -91,11 +94,11 @@ function matchConclusion(conclusion, metastatementNode, metaSubstitutions) {
   return conclusionMatches;
 }
 
-function matchPremisesAndConclusion(premises, conclusion, metastatementNodes, metastatementNode) {
+function matchPremisesAndConclusion(premises, conclusion, metaAssertions, metastatementNode) {
   let premisesMatchConclusion = false;
 
   const metaSubstitutions = [],
-        premisesMatches = matchPremises(premises, metastatementNodes, metaSubstitutions);
+        premisesMatches = matchPremises(premises, metaAssertions, metaSubstitutions);
 
   if (premisesMatches) {
     const conclusionMatches = matchConclusion(conclusion, metastatementNode, metaSubstitutions);

package/bin/verify/conditinalInference.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const verifyMetaproof = require("../verify/metaproof"),
+      MetaproofContext = require("../context/metaproof"),
       verifyConclusion = require("../verify/conclusion"),
       verifyPremiseOrPremises = require("../verify/premiseOrPremises");
 
@@ -13,6 +14,10 @@ const metaproofNodeQuery = nodeQuery("/conditionalInference/metaproof!"),
 function verifyConditionalInference(conditionalInferenceNode, premises, conclusions, context) {
   let conditionalInferenceVerified = false;
 
+  const metaproofContext = MetaproofContext.fromContext(context);
+
+  context = metaproofContext; ///
+
   const premiseOrPremisesNode = premiseOrPremisesNodeQuery(conditionalInferenceNode),
         premiseOrPremisesVerified = verifyPremiseOrPremises(premiseOrPremisesNode, premises, context);
 

package/bin/verify/metaAntecedent.js

@@ -1,6 +1,7 @@
 "use strict";
 
-const verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
+const MetaAssertion = require("../metaAssertion"),
+      verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
 const { nodesQuery } = require("../utilities/query");
 
@@ -16,6 +17,14 @@ function verifyMetaAntecedent(metaAntecedentNode, context) {
           }
         });
 
+  if (metaAntecedentVerified) {
+    unqualifiedMetastatementNodes.forEach((unqualifiedMetastatementNode) => {
+      const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
+
+      context.addMetaAssertion(metaAssertion);
+    });
+  }
+
   return metaAntecedentVerified;
 }
 

package/bin/verify/metaDerivation.js

@@ -1,6 +1,7 @@
 "use strict";
 
-const MetaproofContext = require("../context/metaproof"),
+const MetaAssertion = require("../metaAssertion"),
+      MetaproofContext = require("../context/metaproof"),
       verifyMetaAntecedent = require("../verify/metaAntecedent"),
       verifyQualifiedMetastatement = require("../verify/metastatement/qualified"),
       verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
@@ -19,44 +20,62 @@ function verifyMetaDerivation(metaDerivationNode, context) {
 
   context.setDerived(derived);
 
-  const metaSubproofChildNodes = metaDerivationChildNodesQuery(metaDerivationNode),
-        metaSubproofChildNodesVerified = metaSubproofChildNodes.every((metaSubproofChildNode) => {
-          let metaSubproofChildNodeVerified;
+  const metaDerivationChildNodes = metaDerivationChildNodesQuery(metaDerivationNode),
+        metaDerivationChildNodesVerified = metaDerivationChildNodes.every((metaDerivationChildNode) => {
+          let metaDerivationChildNodeVerified;
 
-          const ruleName = metaSubproofChildNode.getRuleName();
+          const ruleName = metaDerivationChildNode.getRuleName();
 
           switch (ruleName) {
             case META_SUBPROOF_RULE_NAME: {
-              const metaSubproofNode = metaSubproofChildNode,  ///
+              const metaSubproofNode = metaDerivationChildNode,  ///
                     metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, context);
 
-              metaSubproofChildNodeVerified = metaSubproofVerified;  ///
+              if (metaSubproofVerified) {
+                const metaAssertion = MetaAssertion.fromMetaSubproofNode(metaSubproofNode);
+
+                context.addMetaAssertion(metaAssertion);
+
+                metaDerivationChildNodeVerified = true;
+              }
 
               break;
             }
 
             case QUALIFIED_METASTATEMENT_RULE_NAME: {
-              const qualifiedMetastatementNode = metaSubproofChildNode,  ///
+              const qualifiedMetastatementNode = metaDerivationChildNode,  ///
                     qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
 
-              metaSubproofChildNodeVerified = qualifiedMetastatementVerified;  ///
+              if (qualifiedMetastatementVerified) {
+                const metaAssertion = MetaAssertion.fromQualifiedMetastatementNode(qualifiedMetastatementNode);
+
+                context.addMetaAssertion(metaAssertion);
+
+                metaDerivationChildNodeVerified = qualifiedMetastatementVerified; ///
+              }
 
               break;
             }
 
             case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
-              const unqualifiedMetastatementNode = metaSubproofChildNode,  ///
+              const unqualifiedMetastatementNode = metaDerivationChildNode,  ///
                     unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
 
-              metaSubproofChildNodeVerified = unqualifiedMetastatementVerified;  ///
+              if (unqualifiedMetastatementVerified) {
+                const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
+
+                context.addMetaAssertion(metaAssertion);
+
+                metaDerivationChildNodeVerified = true;
+              }
 
               break;
             }
           }
 
-          return metaSubproofChildNodeVerified;
+          return metaDerivationChildNodeVerified;
         }),
-        metaDerivationVerified = metaSubproofChildNodesVerified;  ///
+        metaDerivationVerified = metaDerivationChildNodesVerified;  ///
 
   return metaDerivationVerified;
 }

package/bin/verify/metaproof.js

@@ -3,9 +3,7 @@
 const verifyMetaDerivation = require("../verify/metaDerivation"),
       verifyQualifiedMetastatement = require("../verify/metastatement/qualified");
 
-const { first } = require("../utilities/array"),
-      { nodeQuery } = require("../utilities/query"),
-      { nodeAsString } = require("../utilities/string");
+const { nodeQuery } = require("../utilities/query");
 
 const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement!/metastatement!"),
       metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!"),

package/bin/verify/metastatement/qualified.js

@@ -24,17 +24,17 @@ function verifyQualifiedMetastatement(qualifiedMetastatementNode, context) {
       const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, context);
 
       if (ruleMatchesMetastatement) {
-        context.addMetastatementNode(metastatementNode);
-
-        const metastatementString = nodeAsString(metastatementNode);
-
-        log.info(`Verified the '${metastatementString}' qualified metastatement.`);
-
         qualifiedMetastatementVerified = true;
       }
     }
   }
 
+  if (qualifiedMetastatementVerified) {
+    const metastatementString = nodeAsString(metastatementNode);
+
+    log.info(`Verified the '${metastatementString}' qualified metastatement.`);
+  }
+
   return qualifiedMetastatementVerified;
 }
 

package/bin/verify/metastatement/unqualified.js

@@ -2,6 +2,8 @@
 
 const { loggingUtilities } = require("necessary");
 
+const MetaAssertion = require("../../metaAssertion");
+
 const { nodeQuery } = require("../../utilities/query"),
       { nodeAsString } = require("../../utilities/string");
 
@@ -17,21 +19,20 @@ function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context) {
   if (metastatementNode !== null) {
     const derived = context.isDerived();
 
-    let metastatementPresent = true;  ///
-
     if (derived) {
-      metastatementPresent = context.isMetastatementNodePresent(metastatementNode);
-    }
+      const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode),
+            metaAssertionPresent = context.isMetaAssertionPresent(metaAssertion);
 
-    if (metastatementPresent) {
-      context.addMetastatementNode(metastatementNode);
+      unqualifiedMetastatementVerified = metaAssertionPresent;  ///
+    } else {
+      unqualifiedMetastatementVerified = true;
     }
+  }
 
+  if (unqualifiedMetastatementVerified) {
     const metastatementString = nodeAsString(metastatementNode);
 
     log.info(`Verified the '${metastatementString}' unqualified metastatement.`);
-
-    unqualifiedMetastatementVerified = true;
   }
 
   return unqualifiedMetastatementVerified;

package/bin/verify/premiseOrPremises.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const Premise = require("../premise"),
+      MetaAssertion = require("../metaAssertion"),
       verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
 const { nodeQuery, nodesQuery } = require("../utilities/query");
@@ -21,8 +22,11 @@ function verifyPremiseOrPremises(premiseOrPremisesNode, premises, context) {
   if (premiseOrPremisesVerified) {
     unqualifiedMetastatementNodes.forEach((unqualifiedMetastatementNode) => {
       const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+            metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode),
             premise = Premise.fromMetastatementNode(metastatementNode);
 
+      context.addMetaAssertion(metaAssertion);
+
       premises.push(premise);
     });
   }

package/bin/verify/rule.js

@@ -4,7 +4,6 @@ const { loggingUtilities } = require("necessary");
 
 const Rule = require("../rule"),
       verifyLabels = require("../verify/labels"),
-      MetaproofContext = require("../context/metaproof"),
       verifyConditionalInference = require("../verify/conditinalInference"),
       verifyUnconditionalInference = require("../verify/unconditionalInference");
 
@@ -30,10 +29,6 @@ function verifyRule(ruleNode, context) {
         labelsVerified = verifyLabels(labelNodes, labels, context);
 
   if (labelsVerified) {
-    const metaproofContext = MetaproofContext.fromContext(context);
-
-    context = metaproofContext; ///
-
     const premises = [],
           conclusions = [],
           conditionalInferenceNode = conditionalInferenceNodeQuery(ruleNode),

package/bin/verify/unconditionalInference.js

@@ -1,27 +1,43 @@
 "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 metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+const metaproofNodeQuery = nodeQuery("/unconditionalInference/metaproof!"),
+      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/unconditionalInference/unqualifiedMetastatement!");
 
 function verifyUnconditionalInference(unconditionalInferenceNode, premises, conclusions, context) {
   let unconditionalInferenceVerified = false;
 
-  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(unconditionalInferenceNode);
+  const metaproofContext = MetaproofContext.fromContext(context);
 
-  const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+  context = metaproofContext; ///
+
+  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(unconditionalInferenceNode),
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
 
   if (unqualifiedMetastatementVerified) {
-    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-          conclusion = Conclusion.fromMetastatementNode(metastatementNode);
+    let metaproofVerified = true;
+
+    const metaproofNode = metaproofNodeQuery(unconditionalInferenceNode);
+
+    if (metaproofNode !== null) {
+      metaproofVerified = verifyMetaproof(metaproofNode, context);
+    }
+
+    if (metaproofVerified) {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+            conclusion = Conclusion.fromMetastatementNode(metastatementNode);
 
-    conclusions.push(conclusion);
+      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.268",
+  "version": "0.0.270",
   "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.349",
+    "occam-custom-grammars": "^5.0.351",
     "occam-dom": "^3.0.171",
     "occam-grammar-utilities": "^7.0.66",
-    "occam-grammars": "^1.0.316",
+    "occam-grammars": "^1.0.318",
     "occam-open-cli": "^5.0.37",
     "occam-parsers": "^16.0.122"
   },