occam-verify-cli 0.0.263 → 0.0.264

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/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/inferenceConditional.js

@@ -1,48 +1,28 @@
 "use strict";
 
-const Rule = require("../../rule"),
-      verifyLabels = require("../../verify/labels"),
-      verifyConclusion = require("../../verify/conclusion"),
+const verifyConclusion = require("../../verify/conclusion"),
       verifyPremiseOrPremises = require("../../verify/premiseOrPremises");
 
-const { first } = require("../../utilities/array"),
-      { nodeQuery, nodesQuery } = require("../../utilities/query");
+const { nodeQuery } = require("../../utilities/query");
 
-const labelNodesQuery = nodesQuery("/rule/label"),
-      conclusionNodeQuery = nodeQuery("/inferenceConditional/conclusion!"),
+const conclusionNodeQuery = nodeQuery("/inferenceConditional/conclusion!"),
       premiseOrPremisesNodeQuery = nodeQuery("/inferenceConditional/premise|premises!"),
       inferenceConditionalNodeQuery = nodeQuery("/rule/inferenceConditional!");
 
-function verifyInferenceConditionalRule(ruleNode, rules, context) {
+function verifyInferenceConditionalRule(ruleNode, premises, conclusions, 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;
-        }
-      }
+    const premiseOrPremisesNode = premiseOrPremisesNodeQuery(inferenceConditionalNode),
+          premiseOrPremisesVerified = verifyPremiseOrPremises(premiseOrPremisesNode, premises, context);
+
+    if (premiseOrPremisesVerified) {
+      const conclusionNode = conclusionNodeQuery(inferenceConditionalNode),
+            conclusionVerified = verifyConclusion(conclusionNode, conclusions, context);
+
+      inferenceConditionalRuleVerified = conclusionVerified;
     }
   }
 

package/bin/verify/rule/unqualifiedMetastatement.js

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

package/bin/verify/rule.js

@@ -2,7 +2,9 @@
 
 const { loggingUtilities } = require("necessary");
 
-const verifyMetaproof = require("../verify/metaproof"),
+const Rule = require("../rule"),
+      verifyLabels = require("../verify/labels"),
+      verifyMetaproof = require("../verify/metaproof"),
       MetaproofContext = require("../context/metaproof"),
       verifyInferenceConditionalRule = require("../verify/rule/inferenceConditional"),
       verifyUnqualifiedMetastatementRule = require("../verify/rule/unqualifiedMetastatement");
@@ -24,13 +26,20 @@ function verifyRule(ruleNode, context) {
 
   log.debug(`Verifying the '${labelsString}' rule...`);
 
+  const labels = [],
+        labelsVerified = verifyLabels(labelNodes, labels, context);
+
+  if (labelsVerified) {
+  }
+
   const metaproofContext = MetaproofContext.fromContext(context);
 
   context = metaproofContext; ///
 
-  const rules = [],
-        inferenceConditionalRuleVerified = verifyInferenceConditionalRule(ruleNode, rules, context),
-        unqualifiedMetastatementRuleVerified = verifyUnqualifiedMetastatementRule(ruleNode, rules, context);
+  const premises = [],
+        conclusions = [],
+        inferenceConditionalRuleVerified = verifyInferenceConditionalRule(ruleNode, premises, conclusions, context),
+        unqualifiedMetastatementRuleVerified = verifyUnqualifiedMetastatementRule(ruleNode, premises, conclusions, context);
 
   if (inferenceConditionalRuleVerified || unqualifiedMetastatementRuleVerified) {
     const metaproofNode = metaproofNodeQuery(ruleNode);
@@ -47,8 +56,9 @@ function verifyRule(ruleNode, context) {
   }
 
   if (ruleVerified) {
-    const firstRule = first(rules),
-          rule = firstRule; ///
+    const firstConclusion = first(conclusions),
+          conclusion = firstConclusion, ///
+          rule = Rule.fromPremisesConclusionAndLabels(premises, conclusion, labels);
 
     context.addRule(rule);
 

package/package.json

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