occam-verify-cli 0.0.269 → 0.0.271

package/bin/utilities/permutations.js

@@ -0,0 +1,148 @@
+"use strict";
+
+const { fileSystemUtilities } = require("necessary");
+
+const { push, last, first } = require("../utilities/array"),
+      { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } = require("../constants");
+
+const { writeFile } = fileSystemUtilities;
+
+writePermutationsMatrixFile();
+
+function permutationsMatrixFromNothing() {
+  const permutationsMatrix = [];
+
+  for (let indexesLength = 0; indexesLength <= MAXIMUM_INDEXES_LENGTH; indexesLength++) {
+    const permutationsArray = [];
+
+    for (let permutationLength = 0; permutationLength <= MAXIMUM_PERMUTATION_LENGTH; permutationLength++) {
+      const permutations = ((permutationLength === 0) || (permutationLength > indexesLength)) ?
+                             null :
+                               permutationsFromIndexesLengthAndPermutationLength(indexesLength, permutationLength);
+
+      permutationsArray.push(permutations);
+    }
+
+    permutationsMatrix.push(permutationsArray);
+  }
+
+  return permutationsMatrix;
+}
+
+function writePermutationsMatrixFile() {
+  const permutationsMatrix = permutationsMatrixFromNothing(),
+        permutationsMatrixJSON = JSON.stringify(permutationsMatrix),
+        permutationsMatrixFileName = "./bin/permutationsMatrix.js",
+        permutationsMatrixFileContent = `"use strict";
+        
+const permutationsMatrix = ${permutationsMatrixJSON};
+  
+module.exports = permutationsMatrix;      
+  `;
+
+  writeFile(permutationsMatrixFileName, permutationsMatrixFileContent)
+}
+
+function permutationsFromChoice(choice) {
+  const permutations = [],
+        choiceLength = choice.length;
+
+  if (choiceLength === 1) {
+    const permutation = choice.slice();
+
+    permutations.push(permutation);
+  } else {
+    const innerChoice = choice.slice(0),
+          start = 0,
+          deleteCount = 1,
+          indexes = innerChoice.splice(start, deleteCount),
+          firstIndex = first(indexes),
+          innerPermutations = permutationsFromChoice(innerChoice);
+
+    innerPermutations.forEach((innerPermutation) => {
+      for (let position = 0; position < choiceLength; position++) {
+        const permutation = innerPermutation.slice(0),
+              start = position, ///
+              deleteCount = 0;
+
+        permutation.splice(start, deleteCount, firstIndex);
+
+        permutations.push(permutation);
+      }
+    });
+  }
+
+  return permutations;
+}
+
+function permutationsFromChoices(choices) {
+  const permutations = [];
+
+  choices.forEach((choice) => {
+    const choicePermutations = permutationsFromChoice(choice);
+
+    push(permutations, choicePermutations);
+  });
+
+  return permutations;
+}
+
+function indexesFromIndexesLength(indexesLength) {
+  const indexes = [];
+
+  for (let index = 0; index < indexesLength; index++) {
+    indexes.push(index);
+  }
+
+  return indexes;
+}
+
+function choicesFromIndexesAndChoiceLength(indexes, choiceLength) {
+  const choices = [],
+        indexesLength = indexes.length;
+
+  if (choiceLength === 0) {
+    ///
+  } else if (choiceLength === 1) {
+    for (let position = 0; position < indexesLength; position++) {
+      const index = indexes[position],
+            choice = [
+              index
+            ];
+
+      choices.push(choice);
+    }
+  } else {
+    const innerChoiceLength = choiceLength - 1;
+
+    for (let position = 0; position < indexesLength; position++) {
+      const innerIndexes = indexes.slice(0),
+            start = 0, ///
+            deleteCount = position + 1,
+            deletedIndexes = innerIndexes.splice(start, deleteCount),
+            lastDeletedIndex = last(deletedIndexes),
+            index = lastDeletedIndex, ///
+            innerChoices = choicesFromIndexesAndChoiceLength(innerIndexes, innerChoiceLength);
+
+      innerChoices.forEach((innerChoice) => {
+        const choice = [
+          index,
+          ...innerChoice
+        ];
+
+        choices.push(choice);
+      });
+    }
+  }
+
+  return choices;
+}
+
+function permutationsFromIndexesLengthAndPermutationLength(indexesLength, permutationLength) {
+  const choiceLength = permutationLength, ///
+        indexes = indexesFromIndexesLength(indexesLength),
+        choices = choicesFromIndexesAndChoiceLength(indexes, choiceLength),
+        permutations = permutationsFromChoices(choices);
+
+  return permutations;
+}

package/bin/verify/antecedent.js

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

package/bin/verify/{typeAssertion.js → assertion/type.js}

@@ -2,11 +2,11 @@
 
 const { loggingUtilities } = require("necessary");
 
-const Variable = require("../variable"),
-      verifyTermAsVariable = require("../verify/termAsVariable");
+const Variable = require("../../variable"),
+      verifyTermAsVariable = require("../../verify/termAsVariable");
 
-const { first } = require("../utilities/array"),
-      { nodeQuery, typeNameFromTypeNode } = require("../utilities/query");
+const { first } = require("../../utilities/array"),
+      { nodeQuery, typeNameFromTypeNode } = require("../../utilities/query");
 
 const { log } = loggingUtilities;
 

package/bin/verify/conditinalInference.js

@@ -1,35 +1,38 @@
 "use strict";
 
 const verifyMetaproof = require("../verify/metaproof"),
+      MetaproofContext = require("../context/metaproof"),
       verifyConclusion = require("../verify/conclusion"),
       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) {
   let conditionalInferenceVerified = false;
 
-  const premiseOrPremisesNode = premiseOrPremisesNodeQuery(conditionalInferenceNode),
+  const metaproofContext = MetaproofContext.fromContext(context);
+
+  context = metaproofContext; ///
+
+  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 metaproofNode = metaproofNodeQuery(conditionalInferenceNode);
+      const conclusion = Conclusion.fromMetastatementNode(metastatementNode);
 
-      if (metaproofNode !== null) {
-        metaproofVerified = verifyMetaproof(metaproofNode, context);
-      }
+      conclusions.push(conclusion);
 
-      conditionalInferenceVerified = metaproofVerified; ///
+      conditionalInferenceVerified = true;
     }
   }
 

package/bin/verify/metaAntecedent.js

@@ -3,26 +3,19 @@
 const MetaAssertion = require("../metaAssertion"),
       verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
-const { nodesQuery } = require("../utilities/query");
+const { nodeQuery } = require("../utilities/query");
 
-const unqualifiedMetastatementNodesQuery = nodesQuery("/metaAntecedent/unqualifiedMetastatement");
+const unqualifiedMetastatementNodeQuery = nodeQuery("/metaAntecedent/unqualifiedMetastatement!");
 
 function verifyMetaAntecedent(metaAntecedentNode, context) {
-  const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(metaAntecedentNode),
-        metaAntecedentVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
-          const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
-
-          if (unqualifiedMetastatementVerified) {
-            return true;
-          }
-        });
+  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaAntecedentNode),
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context),
+        metaAntecedentVerified = unqualifiedMetastatementVerified;  ///
 
   if (metaAntecedentVerified) {
-    unqualifiedMetastatementNodes.forEach((unqualifiedMetastatementNode) => {
-      const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
+    const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
 
-      context.addMetaAssertion(metaAssertion);
-    });
+    context.addMetaAssertion(metaAssertion);
   }
 
   return metaAntecedentVerified;

package/bin/verify/metaDerivation.js

@@ -68,6 +68,7 @@ function verifyMetaDerivation(metaDerivationNode, context) {
 
                 metaDerivationChildNodeVerified = true;
               }
+
               break;
             }
           }

package/bin/verify/metaproof.js

@@ -3,20 +3,18 @@
 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!"),
-      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);
@@ -27,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;  ///
     }
   }
 
@@ -46,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

@@ -2,8 +2,6 @@
 
 const { loggingUtilities } = require("necessary");
 
-const MetaAssertion = require("../../metaAssertion");
-
 const { nodeAsString } = require("../../utilities/string"),
       { nodeQuery, referenceNameFromReferenceNode } = require("../../utilities/query");
 
@@ -25,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,7 +4,7 @@ const { loggingUtilities } = require("necessary");
 
 const Rule = require("../rule"),
       verifyLabels = require("../verify/labels"),
-      MetaproofContext = require("../context/metaproof"),
+      verifyMetaproof = require("../verify/metaproof"),
       verifyConditionalInference = require("../verify/conditinalInference"),
       verifyUnconditionalInference = require("../verify/unconditionalInference");
 
@@ -15,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!");
 
@@ -30,34 +31,45 @@ function verifyRule(ruleNode, context) {
         labelsVerified = verifyLabels(labelNodes, labels, context);
 
   if (labelsVerified) {
-    const metaproofContext = MetaproofContext.fromContext(context);
-
-    context = metaproofContext; ///
-
     const premises = [],
           conclusions = [],
           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;
 
-      context.addRule(rule);
+      if (metaproofNode !== null) {
+        const metastatementNode = conclusion.getMetastatementNode();
 
+        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/unconditionalInference.js

@@ -1,23 +1,27 @@
 "use strict";
 
 const Conclusion = require("../conclusion"),
+      MetaproofContext = require("../context/metaproof"),
       verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
 const { nodeQuery } = require("../utilities/query");
 
-const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+const metastatementNodeQuery = nodeQuery("/unconditionalInference/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 metastatementNode = metastatementNodeQuery(unconditionalInferenceNode),
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(unconditionalInferenceNode),
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
 
   if (unqualifiedMetastatementVerified) {
-    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-          conclusion = Conclusion.fromMetastatementNode(metastatementNode);
+    const conclusion = Conclusion.fromMetastatementNode(metastatementNode);
 
     conclusions.push(conclusion);
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.269",
+  "version": "0.0.271",
   "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.350",
+    "occam-custom-grammars": "^5.0.352",
     "occam-dom": "^3.0.171",
     "occam-grammar-utilities": "^7.0.66",
-    "occam-grammars": "^1.0.317",
+    "occam-grammars": "^1.0.319",
     "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;