occam-verify-cli 0.0.262 → 0.0.264

package/bin/verify/metaDerivation.js

@@ -6,100 +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!"),
-      metaSublemmaChildNodesQuery = nodesQuery("/metaDerivation/*"),
-      qualifiedMetastatementNodeQuery = nodeQuery("/metaSublemma/qualifiedMetastatement!"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/metaSublemma/unqualifiedMetastatement!");
+const metaAntecedentNodeQuery = nodeQuery("/metaConditionalProof/metaAntecedent!"),
+      metaDerivationNodeQuery = nodeQuery("/metaConditionalProof/metaDerivation!"),
+      metaDerivationChildNodesQuery = nodesQuery("/metaDerivation/*"),
+      qualifiedMetastatementNodeQuery = nodeQuery("/metaConditionalProof/qualifiedMetastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/metaConditionalProof/unqualifiedMetastatement!");
 
-function verifyMetaDerivation(metaNode, context) {
+function verifyMetaDerivation(metaDerivationNode, context) {
   const derived = true;
 
   context.setDerived(derived);
 
-  const metaSublemmaChildNodes = metaSublemmaChildNodesQuery(metaNode),
-        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 metaAntecedents = [],
-        metaAntecedentNode = metaAntecedentNodeQuery(metaSublemmaNode),
-        metaAntecedentVerified = verifyMetaAntecedent(metaAntecedentNode, metaAntecedents, context);
+  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/metaproof.js

@@ -27,16 +27,18 @@ function verifyMetaproof(metaproofNode, rules, context) {
           qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, context);
 
     if (qualifiedMetastatementVerified) {
-      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-            firstRule = first(rules),
-            rule = firstRule, ///
-            metastatementString = nodeAsString(metastatementNode),
-            conclusionMetastatementNode = rule.getConclusionMetastatementNode(),
-            conclusionMetastatementString = nodeAsString(conclusionMetastatementNode);
-
-      if (metastatementString === conclusionMetastatementString) {
-        metaproofVerified = true;
-      }
+      debugger
+
+      // const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+      //       firstRule = first(rules),
+      //       rule = firstRule, ///
+      //       metastatementString = nodeAsString(metastatementNode),
+      //       conclusionMetastatementNode = rule.getConclusionMetastatementNode(),
+      //       conclusionMetastatementString = nodeAsString(conclusionMetastatementNode);
+      //
+      // if (metastatementString === conclusionMetastatementString) {
+      //   metaproofVerified = true;
+      // }
     }
   }
 

package/bin/verify/metastatement/qualified.js

@@ -2,8 +2,7 @@
 
 const { loggingUtilities } = require("necessary");
 
-const { matchRule } = require("../../utilities/rule"),
-      { nodeAsString } = require("../../utilities/string"),
+const { nodeAsString } = require("../../utilities/string"),
       { nodeQuery, referenceNameFromReferenceNode } = require("../../utilities/query");
 
 const { log } = loggingUtilities;
@@ -22,9 +21,9 @@ function verifyQualifiedMetastatement(qualifiedMetastatementNode, context) {
           rule = context.findRuleByReferenceName(referenceName);
 
     if (rule !== null) {
-      const ruleMatches = matchRule(rule, metastatementNode, context);
+      const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, context);
 
-      if (ruleMatches) {
+      if (ruleMatchesMetastatement) {
         context.addMetastatementNode(metastatementNode);
 
         const metastatementString = nodeAsString(metastatementNode);
@@ -40,4 +39,3 @@ function verifyQualifiedMetastatement(qualifiedMetastatementNode, context) {
 }
 
 module.exports = verifyQualifiedMetastatement;
-

package/bin/verify/{premise.js → premiseOrPremises.js}

@@ -8,9 +8,9 @@ const { nodeQuery, nodesQuery } = require("../utilities/query");
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement"),
       unqualifiedMetastatementNodesQuery = nodesQuery("/premise|premises/unqualifiedMetastatement");
 
-function verifyPremise(premiseNode, premises, context) {
-  const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(premiseNode),
-        premiseVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
+function verifyPremiseOrPremises(premiseOrPremisesNode, premises, context) {
+  const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(premiseOrPremisesNode),
+        premiseOrPremisesVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
           const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
 
           if (unqualifiedMetastatementVerified) {
@@ -18,18 +18,16 @@ function verifyPremise(premiseNode, premises, context) {
           }
         });
 
-  if (premiseVerified) {
-    const metastatementNodes = unqualifiedMetastatementNodes.map((unqualifiedMetastatementNode) => {
-            const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+  if (premiseOrPremisesVerified) {
+    unqualifiedMetastatementNodes.forEach((unqualifiedMetastatementNode) => {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+            premise = Premise.fromMetastatementNode(metastatementNode);
 
-            return metastatementNode;
-          }),
-          premise = Premise.fromMetastatementNodes(metastatementNodes);
-
-    premises.push(premise);
+      premises.push(premise);
+    });
   }
 
-  return premiseVerified;
+  return premiseOrPremisesVerified;
 }
 
-module.exports = verifyPremise;
+module.exports = verifyPremiseOrPremises;

package/bin/verify/rule/inferenceConditional.js

@@ -1,50 +1,28 @@
 "use strict";
 
-const Rule = require("../../rule"),
-      verifyLabels = require("../../verify/labels"),
-      verifyPremise = require("../../verify/premise"),
-      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"),
-      premiseNodeQuery = nodeQuery("/inferenceConditional/premise|premises!"),
-      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 = [],
-            premiseNode = premiseNodeQuery(inferenceConditionalNode),
-            premiseVerified = verifyPremise(premiseNode, premises, context);
-
-      if (premiseVerified) {
-        const conclusions = [],
-              conclusionNode = conclusionNodeQuery(inferenceConditionalNode),
-              conclusionVerified = verifyConclusion(conclusionNode, conclusions, context);
-
-        if (conclusionVerified) {
-          const firstPremise = first(premises),
-                firstConclusion = first(conclusions),
-                premise = firstPremise, ///
-                conclusion = firstConclusion, ///
-                rule = Rule.fromPremiseConclusionAndLabels(premise, 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,36 +1,28 @@
 "use strict";
 
-const Rule = require("../../rule"),
-      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),
-              rule = Rule.fromMetastatementNodeAndLabels(metastatementNode, 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.262",
+  "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.342",
+    "occam-custom-grammars": "^5.0.345",
     "occam-dom": "^3.0.171",
     "occam-grammar-utilities": "^7.0.66",
-    "occam-grammars": "^1.0.309",
+    "occam-grammars": "^1.0.312",
     "occam-open-cli": "^5.0.37",
     "occam-parsers": "^16.0.122"
   },

package/bin/metaAntecedent.js

@@ -1,19 +0,0 @@
-"use strict";
-
-class MetaAntecedent {
-  constructor(metastatementNodes) {
-    this.metastatementNodes = metastatementNodes;
-  }
-
-  getMetastatementNodes() {
-    return this.metastatementNodes;
-  }
-
-  static fromMetastatementNodes(metastatementNodes) {
-    const metaAntecedent = new MetaAntecedent(metastatementNodes);
-
-    return metaAntecedent;
-  }
-}
-
-module.exports = MetaAntecedent;

package/bin/metaConsequent.js

@@ -1,19 +0,0 @@
-"use strict";
-
-class MetaConsequent {
-  constructor(metastatementNode) {
-    this.metastatementNode = metastatementNode;
-  }
-
-  getMetastatementNode() {
-    return this.metastatementNode;
-  }
-
-  static fromStatementNode(metastatementNode) {
-    const metaConsequent = new MetaConsequent(metastatementNode);
-
-    return metaConsequent;
-  }
-}
-
-module.exports = MetaConsequent;