occam-verify-cli 0.0.263 → 0.0.265

package/bin/ruleNames.js

@@ -4,7 +4,7 @@ const TERM_RULE_NAME = "term",
       TYPE_RULE_NAME = "type",
       ARGUMENT_RULE_NAME = "argument",
       METAVARIABLE_RULE_NAME = "metavariable",
-      META_SUBLEMMA_RULE_NAME = "metaSublemma",
+      META_CONDITIONAL_PROOF_RULE_NAME = "metaConditionalProof",
       QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement",
       UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";
 
@@ -13,7 +13,7 @@ module.exports = {
   TYPE_RULE_NAME,
   ARGUMENT_RULE_NAME,
   METAVARIABLE_RULE_NAME,
-  META_SUBLEMMA_RULE_NAME,
+  META_CONDITIONAL_PROOF_RULE_NAME,
   QUALIFIED_METASTATEMENT_RULE_NAME,
   UNQUALIFIED_METASTATEMENT_RULE_NAME
 };

package/bin/verify/conditinalInference.js

@@ -0,0 +1,45 @@
+"use strict";
+
+const verifyMetaproof = require("../../verify/metaproof"),
+      verifyConclusion = require("../../verify/conclusion"),
+      verifyPremiseOrPremises = require("../../verify/premiseOrPremises");
+
+const { nodeQuery } = require("../../utilities/query");
+
+const metaproofNodeQuery = nodeQuery("/rule/metaproof!"),
+      conclusionNodeQuery = nodeQuery("/conditionalInference/conclusion!"),
+      premiseOrPremisesNodeQuery = nodeQuery("/conditionalInference/premise|premises!");
+
+function verifyConditionalInference(ruleNode, premises, conclusions, context) {
+  let conditinalInferenceVerified = false;
+
+  const inferenceConditionalNode = inferenceConditionalNodeQuery(ruleNode);
+
+  if (inferenceConditionalNode !== null) {
+    const premiseOrPremisesNode = premiseOrPremisesNodeQuery(inferenceConditionalNode),
+          premiseOrPremisesVerified = verifyPremiseOrPremises(premiseOrPremisesNode, premises, context);
+
+    if (premiseOrPremisesVerified) {
+      const conclusionNode = conclusionNodeQuery(inferenceConditionalNode),
+            conclusionVerified = verifyConclusion(conclusionNode, conclusions, context);
+
+
+      const metaproofNode = metaproofNodeQuery(ruleNode);
+
+      let metaproofVerified = true;
+
+      if (metaproofNode !== null) {
+        metaproofVerified = verifyMetaproof(metaproofNode, rules, context);
+      }
+
+      if (metaproofVerified) {
+        ruleVerified = true;
+      }
+      conditinalInferenceVerified = conclusionVerified;
+    }
+  }
+
+  return conditinalInferenceVerified;
+}
+
+module.exports = verifyConditionalInference;

package/bin/verify/metaDerivation.js

@@ -6,99 +6,99 @@ const MetaproofContext = require("../context/metaproof"),
       verifyUnqualifiedMetastatement = require("../verify/metastatement/unqualified");
 
 const { nodeQuery, nodesQuery } = require("../utilities/query"),
-      { META_SUBLEMMA_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } = require("../ruleNames");
+      { META_CONDITIONAL_PROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } = require("../ruleNames");
 
-const metaAntecedentNodeQuery = nodeQuery("/metaSublemma/metaAntecedent!"),
-      metaDerivationNodeQuery = nodeQuery("/metaSublemma/metaDerivation!"),
+const metaAntecedentNodeQuery = nodeQuery("/metaConditionalProof/metaAntecedent!"),
+      metaDerivationNodeQuery = nodeQuery("/metaConditionalProof/metaDerivation!"),
       metaDerivationChildNodesQuery = nodesQuery("/metaDerivation/*"),
-      qualifiedMetastatementNodeQuery = nodeQuery("/metaSublemma/qualifiedMetastatement!"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/metaSublemma/unqualifiedMetastatement!");
+      qualifiedMetastatementNodeQuery = nodeQuery("/metaConditionalProof/qualifiedMetastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/metaConditionalProof/unqualifiedMetastatement!");
 
 function verifyMetaDerivation(metaDerivationNode, context) {
   const derived = true;
 
   context.setDerived(derived);
 
-  const metaSublemmaChildNodes = metaDerivationChildNodesQuery(metaDerivationNode),
-        metaSublemmaChildNodesVerified = metaSublemmaChildNodes.every((metaSublemmaChildNode) => {
-          let metaSublemmaChildNodeVerified;
+  const metaConditionalProofChildNodes = metaDerivationChildNodesQuery(metaDerivationNode),
+        metaConditionalProofChildNodesVerified = metaConditionalProofChildNodes.every((metaConditionalProofChildNode) => {
+          let metaConditionalProofChildNodeVerified;
 
-          const ruleName = metaSublemmaChildNode.getRuleName();
+          const ruleName = metaConditionalProofChildNode.getRuleName();
 
           switch (ruleName) {
-            case META_SUBLEMMA_RULE_NAME: {
-              const metaSublemmaNode = metaSublemmaChildNode,  ///
-                    metaSublemmaVerified = verifyMetaSublemma(metaSublemmaNode, context);
+            case META_CONDITIONAL_PROOF_RULE_NAME: {
+              const metaConditionalProofNode = metaConditionalProofChildNode,  ///
+                    metaConditionalProofVerified = verifyMetaConditionalProof(metaConditionalProofNode, context);
 
-              metaSublemmaChildNodeVerified = metaSublemmaVerified;  ///
+              metaConditionalProofChildNodeVerified = metaConditionalProofVerified;  ///
 
               break;
             }
 
             case QUALIFIED_METASTATEMENT_RULE_NAME: {
-              const qualifiedMetastatementNode = metaSublemmaChildNode,  ///
+              const qualifiedMetastatementNode = metaConditionalProofChildNode,  ///
                     qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
 
-              metaSublemmaChildNodeVerified = qualifiedMetastatementVerified;  ///
+              metaConditionalProofChildNodeVerified = qualifiedMetastatementVerified;  ///
 
               break;
             }
 
             case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
-              const unqualifiedMetastatementNode = metaSublemmaChildNode,  ///
+              const unqualifiedMetastatementNode = metaConditionalProofChildNode,  ///
                     unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
 
-              metaSublemmaChildNodeVerified = unqualifiedMetastatementVerified;  ///
+              metaConditionalProofChildNodeVerified = unqualifiedMetastatementVerified;  ///
 
               break;
             }
           }
 
-          return metaSublemmaChildNodeVerified;
+          return metaConditionalProofChildNodeVerified;
         }),
-        metaDerivationVerified = metaSublemmaChildNodesVerified;  ///
+        metaDerivationVerified = metaConditionalProofChildNodesVerified;  ///
 
   return metaDerivationVerified;
 }
 
 module.exports = verifyMetaDerivation;
 
-function verifyMetaSublemma(metaSublemmaNode, context) {
-  let metaSublemmaVerified = false;
+function verifyMetaConditionalProof(metaConditionalProofNode, context) {
+  let metaConditionalProofVerified = false;
 
   const metaproofContext = MetaproofContext.fromContext(context);
 
   context = metaproofContext; ///
 
-  const metaAntecedentNode = metaAntecedentNodeQuery(metaSublemmaNode),
+  const metaAntecedentNode = metaAntecedentNodeQuery(metaConditionalProofNode),
         metaAntecedentVerified = verifyMetaAntecedent(metaAntecedentNode, context);
 
   if (metaAntecedentVerified) {
     let metaDerivationVerified = true;
 
-    const metaDerivationNode = metaDerivationNodeQuery(metaSublemmaNode);
+    const metaDerivationNode = metaDerivationNodeQuery(metaConditionalProofNode);
 
     if (metaDerivationNode !== null) {
       metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, context);
     }
 
     if (metaDerivationVerified) {
-      const qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(metaSublemmaNode),
-            unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSublemmaNode);
+      const qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(metaConditionalProofNode),
+            unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaConditionalProofNode);
 
       if (qualifiedMetastatementNode !== null) {
         const qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
 
-        metaSublemmaVerified = qualifiedMetastatementVerified;  ///
+        metaConditionalProofVerified = qualifiedMetastatementVerified;  ///
       }
 
       if (unqualifiedMetastatementNode !== null) {
         const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
 
-        metaSublemmaVerified = unqualifiedMetastatementVerified;  ///
+        metaConditionalProofVerified = unqualifiedMetastatementVerified;  ///
       }
     }
   }
 
-  return metaSublemmaVerified;
+  return metaConditionalProofVerified;
 }

package/bin/verify/rule.js

@@ -2,10 +2,11 @@
 
 const { loggingUtilities } = require("necessary");
 
-const verifyMetaproof = require("../verify/metaproof"),
+const Rule = require("../rule"),
+      verifyLabels = require("../verify/labels"),
       MetaproofContext = require("../context/metaproof"),
-      verifyInferenceConditionalRule = require("../verify/rule/inferenceConditional"),
-      verifyUnqualifiedMetastatementRule = require("../verify/rule/unqualifiedMetastatement");
+      verifyConditionalInference = require("../verify/conditinalInference"),
+      verifyUnconditionalInference = require("../verify/unconditionalInference");
 
 const { first } = require("../utilities/array"),
       { nodesAsString } = require("../utilities/string"),
@@ -14,7 +15,8 @@ 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!");
 
 function verifyRule(ruleNode, context) {
   let ruleVerified = false;
@@ -24,35 +26,40 @@ function verifyRule(ruleNode, context) {
 
   log.debug(`Verifying the '${labelsString}' rule...`);
 
-  const metaproofContext = MetaproofContext.fromContext(context);
+  const labels = [],
+        labelsVerified = verifyLabels(labelNodes, labels, context);
 
-  context = metaproofContext; ///
+  if (labelsVerified) {
+    const metaproofContext = MetaproofContext.fromContext(context);
 
-  const rules = [],
-        inferenceConditionalRuleVerified = verifyInferenceConditionalRule(ruleNode, rules, context),
-        unqualifiedMetastatementRuleVerified = verifyUnqualifiedMetastatementRule(ruleNode, rules, context);
+    context = metaproofContext; ///
 
-  if (inferenceConditionalRuleVerified || unqualifiedMetastatementRuleVerified) {
-    const metaproofNode = metaproofNodeQuery(ruleNode);
+    const premises = [],
+          conclusions = [],
+          conditionalInferenceNode = conditionalInferenceNodeQuery(ruleNode),
+          unconditionalInferenceNode = unconditionalInferenceNodeQuery(ruleNode);
 
-    let metaproofVerified = true;
+    if (conditionalInferenceNode !== null) {
+      const conditionalInferenceVerified = verifyConditionalInference(ruleNode, premises, conclusions, context);
 
-    if (metaproofNode !== null) {
-      metaproofVerified = verifyMetaproof(metaproofNode, rules, context);
+      ruleVerified = conditionalInferenceVerified;  ///
     }
 
-    if (metaproofVerified) {
-      ruleVerified = true;
+    if (unconditionalInferenceNode !== null) {
+      const unconditionalInferenceVerified = verifyUnconditionalInference(ruleNode, premises, conclusions, context);
+
+      ruleVerified = unconditionalInferenceVerified;  ///
     }
-  }
 
-  if (ruleVerified) {
-    const firstRule = first(rules),
-          rule = firstRule; ///
+    if (ruleVerified) {
+      const firstConclusion = first(conclusions),
+            conclusion = firstConclusion, ///
+            rule = Rule.fromPremisesConclusionAndLabels(premises, conclusion, labels);
 
-    context.addRule(rule);
+      context.addRule(rule);
 
-    log.info(`Verified the '${labelsString}' rule.`);
+      log.info(`Verified the '${labelsString}' rule.`);
+    }
   }
 
   return ruleVerified;

package/bin/verify/unconditionalInference.js

@@ -0,0 +1,32 @@
+"use strict";
+
+const Conclusion = require("../../conclusion"),
+      verifyUnqualifiedMetastatement = require("../../verify/metastatement/unqualified");
+
+const { nodeQuery } = require("../../utilities/query");
+
+const metastatementNodeQuery = nodeQuery("/*/metastatement"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/rule/unqualifiedMetastatement!");
+
+function verifyUnqualifiedMetastatementRule(ruleNode, premises, conclusions, context) {
+  let unqualifiedMetastatementRuleVerified = false;
+
+  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(ruleNode);
+
+  if (unqualifiedMetastatementNode !== null) {
+    const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+
+    if (unqualifiedMetastatementVerified) {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+            conclusion = Conclusion.fromMetastatementNode(metastatementNode);
+
+      conclusions.push(conclusion);
+
+      unqualifiedMetastatementRuleVerified = true;
+    }
+  }
+
+  return unqualifiedMetastatementRuleVerified;
+}
+
+module.exports = verifyUnqualifiedMetastatementRule;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.263",
+  "version": "0.0.265",
   "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.344",
+    "occam-custom-grammars": "^5.0.346",
     "occam-dom": "^3.0.171",
     "occam-grammar-utilities": "^7.0.66",
-    "occam-grammars": "^1.0.311",
+    "occam-grammars": "^1.0.313",
     "occam-open-cli": "^5.0.37",
     "occam-parsers": "^16.0.122"
   },

package/bin/verify/rule/inferenceConditional.js

@@ -1,52 +0,0 @@
-"use strict";
-
-const Rule = require("../../rule"),
-      verifyLabels = require("../../verify/labels"),
-      verifyConclusion = require("../../verify/conclusion"),
-      verifyPremiseOrPremises = require("../../verify/premiseOrPremises");
-
-const { first } = require("../../utilities/array"),
-      { nodeQuery, nodesQuery } = require("../../utilities/query");
-
-const labelNodesQuery = nodesQuery("/rule/label"),
-      conclusionNodeQuery = nodeQuery("/inferenceConditional/conclusion!"),
-      premiseOrPremisesNodeQuery = nodeQuery("/inferenceConditional/premise|premises!"),
-      inferenceConditionalNodeQuery = nodeQuery("/rule/inferenceConditional!");
-
-function verifyInferenceConditionalRule(ruleNode, rules, context) {
-  let inferenceConditionalRuleVerified = false;
-
-  const inferenceConditionalNode = inferenceConditionalNodeQuery(ruleNode);
-
-  if (inferenceConditionalNode !== null) {
-    const labels = [],
-          labelNodes = labelNodesQuery(ruleNode),
-          labelsVerified = verifyLabels(labelNodes, labels, context);
-
-    if (labelsVerified) {
-      const premises = [],
-            premiseOrPremisesNode = premiseOrPremisesNodeQuery(inferenceConditionalNode),
-            premiseOrPremisesVerified = verifyPremiseOrPremises(premiseOrPremisesNode, premises, context);
-
-      if (premiseOrPremisesVerified) {
-        const conclusions = [],
-              conclusionNode = conclusionNodeQuery(inferenceConditionalNode),
-              conclusionVerified = verifyConclusion(conclusionNode, conclusions, context);
-
-        if (conclusionVerified) {
-          const firstConclusion = first(conclusions),
-                conclusion = firstConclusion, ///
-                rule = Rule.fromPremisesConclusionAndLabels(premises, conclusion, labels);
-
-          rules.push(rule);
-
-          inferenceConditionalRuleVerified = true;
-        }
-      }
-    }
-  }
-
-  return inferenceConditionalRuleVerified;
-}
-
-module.exports = verifyInferenceConditionalRule;

package/bin/verify/rule/unqualifiedMetastatement.js

@@ -1,43 +0,0 @@
-"use strict";
-
-const Rule = require("../../rule"),
-      Conclusion = require("../../conclusion"),
-      verifyLabels = require("../../verify/labels"),
-      verifyUnqualifiedMetastatement = require("../../verify/metastatement/unqualified");
-
-const { nodeQuery, nodesQuery } = require("../../utilities/query");
-
-const labelNodesQuery = nodesQuery("/rule/label"),
-      metastatementNodeQuery = nodeQuery("/*/metastatement"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/rule/unqualifiedMetastatement!");
-
-function verifyUnqualifiedMetastatementRule(ruleNode, rules, context) {
-  let unqualifiedMetastatementRuleVerified = false;
-
-  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(ruleNode);
-
-  if (unqualifiedMetastatementNode !== null) {
-    const labels = [],
-          labelNodes = labelNodesQuery(ruleNode),
-          labelsVerified = verifyLabels(labelNodes, labels, context);
-
-    if (labelsVerified) {
-      const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
-
-      if (unqualifiedMetastatementVerified) {
-        const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-              conclusion = Conclusion.fromMetastatementNode(metastatementNode),
-              premises = [],
-              rule = Rule.fromPremisesConclusionAndLabels(premises, conclusion, labels);
-
-        rules.push(rule);
-
-        unqualifiedMetastatementRuleVerified = true;
-      }
-    }
-  }
-
-  return unqualifiedMetastatementRuleVerified;
-}
-
-module.exports = verifyUnqualifiedMetastatementRule;