occam-verify-cli 0.0.504 → 0.0.506

package/src/step/metaproof.js

@@ -4,14 +4,13 @@ import { first, second } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 import { matchBracketedNonTerminalNode } from "../utilities/node";
 
-const metastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
-      metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion"),
-      qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/metaSubproof/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
+const metastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
+      ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion"),
+      qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/ruleSubproof/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
 
 export default class MetaproofStep {
-  constructor(ruleSubproofNode, metaSubproofNode, metastatementNode) {
+  constructor(ruleSubproofNode, metastatementNode) {
     this.ruleSubproofNode = ruleSubproofNode;
-    this.metaSubproofNode = metaSubproofNode;
     this.metastatementNode = metastatementNode;
   }
 
@@ -19,10 +18,6 @@ export default class MetaproofStep {
     return this.ruleSubproofNode;
   }
 
-  getMetaSubproofNode() {
-    return this.metaSubproofNode;
-  }
-
   getMetastatementNode() {
     return this.metastatementNode;
   }
@@ -30,12 +25,12 @@ export default class MetaproofStep {
   matchMetastatement(metastatementNode) {
     let metastatementMatches;
 
-    const metaSubproofAssertionNode = metaSubproofAssertionNodeQuery(metastatementNode);
+    const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(metastatementNode);
 
-    if (metaSubproofAssertionNode !== null) {
-      const metaSubproofAssertionMatches = this.matchMetaSubproofAssertion(metaSubproofAssertionNode);
+    if (ruleSubproofAssertionNode !== null) {
+      const ruleSubproofAssertionMatches = this.matchRuleSubproofAssertion(ruleSubproofAssertionNode);
 
-      metastatementMatches = metaSubproofAssertionMatches;  ///
+      metastatementMatches = ruleSubproofAssertionMatches;  ///
     } else {
       const metastatementsMatch = this.matchMetastatements(metastatementNode);
 
@@ -60,54 +55,44 @@ export default class MetaproofStep {
     return metastatementsMatch;
   }
 
-  matchMetaSubproofAssertion(metaSubproofAssertionNode) {
-    let metaSubproofAssertionMatches = false;
+  matchRuleSubproofAssertion(ruleSubproofAssertionNode) {
+    let ruleSubproofAssertionMatches = false;
 
-    if (this.metaSubproofNode !== null) {
-      const metaSubproofAssertionMetastatementNodes = metastatementNodesQuery(metaSubproofAssertionNode),
-            firstMetaSubproofAssertionMetastatementNode = first(metaSubproofAssertionMetastatementNodes),
-            qualifiedOrUnqualifiedMetastatementMetastatementNodes = qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery(this.metaSubproofNode),
+    if (this.ruleSubproofNode !== null) {
+      const ruleSubproofAssertionMetastatementNodes = metastatementNodesQuery(ruleSubproofAssertionNode),
+            firstRuleSubproofAssertionMetastatementNode = first(ruleSubproofAssertionMetastatementNodes),
+            qualifiedOrUnqualifiedMetastatementMetastatementNodes = qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery(this.ruleSubproofNode),
             firstQualifiedOrUnqualifiedMetastatementMetastatementNode = first(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
 
-      const nonTerminalNodeA = firstMetaSubproofAssertionMetastatementNode,  ///
+      const nonTerminalNodeA = firstRuleSubproofAssertionMetastatementNode,  ///
             nonTerminalNodeB = firstQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
             bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
 
       if (bracketedNodeMatches) {
-        const secondMetaSubproofAssertionMetastatementNode = second(metaSubproofAssertionMetastatementNodes),
+        const secondRuleSubproofAssertionMetastatementNode = second(ruleSubproofAssertionMetastatementNodes),
               secondQualifiedOrUnqualifiedMetastatementMetastatementNode = second(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
 
-        const nonTerminalNodeA = secondMetaSubproofAssertionMetastatementNode, ///
+        const nonTerminalNodeA = secondRuleSubproofAssertionMetastatementNode, ///
               nonTerminalNodeB = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
               bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
 
-        metaSubproofAssertionMatches = bracketedNodeMatches; ///
+        ruleSubproofAssertionMatches = bracketedNodeMatches; ///
       }
     }
 
-    return metaSubproofAssertionMatches;
+    return ruleSubproofAssertionMatches;
   }
 
   static fromRuleSubproofNode(ruleSubproofNode) {
-    const metaSubproofNode = null,
-          metastatementNode = null,
-          metaProofStep = new MetaproofStep(ruleSubproofNode, metaSubproofNode, metastatementNode);
-
-    return metaProofStep;
-  }
-
-  static fromMetaSubproofNode(metaSubproofNode) {
-    const ruleSubproofNode = null,
-          metastatementNode = null,
-          metaProofStep = new MetaproofStep(ruleSubproofNode, metaSubproofNode, metastatementNode);
+    const metastatementNode = null,
+          metaProofStep = new MetaproofStep(ruleSubproofNode, metastatementNode);
 
     return metaProofStep;
   }
 
   static fromMetastatementNode(metastatementNode) {
     const ruleSubproofNode = null,
-          metaSubproofNode = null,
-          metaProofStep = new MetaproofStep(ruleSubproofNode, metaSubproofNode, metastatementNode);
+          metaProofStep = new MetaproofStep(ruleSubproofNode, metastatementNode);
 
     return metaProofStep;
   }

package/src/theorem.js

@@ -9,5 +9,5 @@ export default class Theorem extends AxiomLemmaTheorem {
 
   static fromJSON(json, releaseContext) { return AxiomLemmaTheorem.fromJSON(Theorem, json, releaseContext); }
 
-  static fromLabelsSuppositionsAndConsequence(labels, antecedents, consequence) { return AxiomLemmaTheorem.fromLabelsSuppositionsAndConsequence(Theorem, labels, antecedents, consequence); }
+  static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheorem.fromLabelsSuppositionsAndConsequence(Theorem, labels, suppositions, consequence); }
 }

package/src/verify/metaDerivation.js

@@ -1,18 +1,14 @@
 "use strict";
 
 import MetaproofStep from "../step/metaproof";
-import MetaproofContext from "../context/metaproof";
-import verifyMetaSupposition from "../verify/metaSupposition";
 import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery, nodesQuery } from "../utilities/query";
-import { META_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
 
 const childNodesQuery = nodesQuery("/metaDerivation|metaSubDerivation/*"),
-      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
-      metaSuppositionNodesQuery = nodesQuery("/metaSubproof/metaSupposition"),
-      metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
+      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
 
 export default function verifyMetaDerivation(metaDerivationNode, metaproofContext) {
   let metaDerivationVerified;
@@ -36,76 +32,12 @@ export default function verifyMetaDerivation(metaDerivationNode, metaproofContex
   return metaDerivationVerified;
 }
 
-function verifyMetaSubDerivation(metaSubDerivationNode, metaproofContext) {
-  let metaSubDerivationVerified;
-
-  metaproofContext.begin(metaSubDerivationNode);
-
-  const childNodes = childNodesQuery(metaSubDerivationNode);
-
-  metaSubDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, metaproofContext);
-
-    if (childVerified) {
-      return true;
-    }
-  });
-
-  metaSubDerivationVerified ?
-    metaproofContext.complete(metaSubDerivationNode) :
-      metaproofContext.halt(metaSubDerivationNode);
-
-  return metaSubDerivationVerified;
-}
-
-function verifyMetaSubproof(metaSubproofNode, metaproofContext) {
-  let metaSubproofVerified = false;
-
-  metaproofContext = MetaproofContext.fromMetaproofContext(metaproofContext); ///
-
-  const metaSuppositions = [],
-        metaSuppositionNodes = metaSuppositionNodesQuery(metaSubproofNode),
-        metaSuppositionsVerified = metaSuppositionNodes.every((metaSuppositionNode) => {
-          const metaSuppositionVerified = verifyMetaSupposition(metaSuppositionNode, metaSuppositions, metaproofContext);
-
-          if (metaSuppositionVerified) {
-            return true;
-          }
-        });
-
-  if (metaSuppositionsVerified) {
-    const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
-          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, metaproofContext);
-
-    if (metaSubDerivationVerified) {
-      metaSubproofVerified = true;
-    }
-  }
-
-  return metaSubproofVerified;
-}
-
 function verifyChild(childNode, metaproofContext) {
   let childVerified;
 
   const childNodeRuleName = childNode.getRuleName();
 
   switch (childNodeRuleName) {
-    case META_SUBPROOF_RULE_NAME: {
-      const metaSubproofNode = childNode,  ///
-            metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, metaproofContext);
-
-      if (metaSubproofVerified) {
-        const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);
-
-        metaproofContext.addMetaproofStep(metaproofStep);
-
-        childVerified = true;
-      }
-
-      break;
-    }
-
     case QUALIFIED_METASTATEMENT_RULE_NAME: {
       const qualifiedMetastatementNode = childNode,  ///
             qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext);

package/src/verify/ruleProof.js

@@ -7,7 +7,7 @@ import { nodeQuery } from "../utilities/query";
 
 const ruleDerivationNodeQuery = nodeQuery("/ruleProof/ruleDerivation!");
 
-export default function verifyMetaproof(ruleProofNode, conclusion, metaproofContext) {
+export default function verifyRuleProof(ruleProofNode, conclusion, metaproofContext) {
   let ruleProofVerified = false;
 
   metaproofContext.begin(ruleProofNode);