occam-verify-cli 0.0.892 → 0.0.893

package/src/verify/metastatement/unqualified.js

@@ -9,32 +9,29 @@ const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatemen
 export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext) {
   let unqualifiedMetastatementVerified = false;
 
-  const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+  const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+        unqualifiedMetastatementString = localMetaContext.nodeAsString(unqualifiedMetastatementNode);
 
-  if (metastatementNode !== null) {
-    const metastatementString = localMetaContext.nodeAsString(metastatementNode);
+  localMetaContext.trace(`Verifying the '${unqualifiedMetastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
 
-    localMetaContext.trace(`Verifying the '${metastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
+  if (derived) {
+    const metastatementMatches = localMetaContext.matchMetastatement(metastatementNode);
 
-    if (derived) {
-      const metastatementMatches = localMetaContext.matchMetastatement(metastatementNode);
-
-      unqualifiedMetastatementVerified = metastatementMatches;  ///
-    }
+    unqualifiedMetastatementVerified = metastatementMatches;  ///
+  }
 
-    if (!unqualifiedMetastatementVerified) {
-      const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
-              const verifiedAhead = true;
+  if (!unqualifiedMetastatementVerified) {
+    const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localMetaContext, () => {
+            const verifiedAhead = true;
 
-              return verifiedAhead;
-            });
+            return verifiedAhead;
+          });
 
-      unqualifiedMetastatementVerified = metastatementVerified; ///
-    }
+    unqualifiedMetastatementVerified = metastatementVerified; ///
+  }
 
-    if (unqualifiedMetastatementVerified) {
-      localMetaContext.debug(`...verified the '${metastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
-    }
+  if (unqualifiedMetastatementVerified) {
+    localMetaContext.debug(`...verified the '${unqualifiedMetastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
   }
 
   return unqualifiedMetastatementVerified;

package/src/verify/proofStep.js

@@ -0,0 +1,88 @@
+"use strict";
+
+import ProofStep from "../step/proof";
+import verifySubproof from "../verify/subproof";
+import verifySubDerivation from "../verify/subDerivation";
+import verifyQualifiedStatement from "../verify/statement/qualified";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+
+import { nodeQuery } from "../utilities/query";
+import { assignAssignment } from "../utilities/assignments";
+
+const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof!"),
+      statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
+      qualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/qualifiedStatement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/unqualifiedStatement!");
+
+export default function verifyProofStep(proofStepNode, localContext) {
+  let proofStepVerified = false;
+
+  const subproofNode = subproofNodeQuery(proofStepNode),
+        qualifiedStatementNode = qualifiedStatementNodeQuery(proofStepNode),
+        unqualifiedStatementNode = unqualifiedStatementNodeQuery(proofStepNode);
+
+  if (false) {
+    ///
+  } else if (subproofNode !== null) {
+    let subproofVerified;
+
+    subproofVerified = verifySubproof(subproofNode, localContext);
+
+    if (subproofVerified) {
+      const proofStep = ProofStep.fromSubproofNode(subproofNode);
+
+      localContext.addProofStep(proofStep);
+
+      proofStepVerified = true;
+    }
+  } else if (qualifiedStatementNode !== null) {
+    let qualifiedStatementVerified;
+
+    const assignments = [];
+
+    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
+
+    if (qualifiedStatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localContext);
+
+      qualifiedStatementVerified = assignmentAssigned; ///
+    }
+
+    if (qualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(qualifiedStatementNode),
+            proofStep = ProofStep.fromStatementNode(statementNode);
+
+      localContext.addProofStep(proofStep);
+
+      proofStepVerified = true;
+    }
+  } else if (unqualifiedStatementNode !== null) {
+    let unqualifiedStatementVerified;
+
+    const derived = true,
+          assignments = [];
+
+    unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+
+    if (unqualifiedStatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localContext);
+
+      unqualifiedStatementVerified = assignmentAssigned;  ///
+    }
+
+    if (unqualifiedStatementVerified) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode),
+            proofStep = ProofStep.fromStatementNode(statementNode);
+
+      localContext.addProofStep(proofStep);
+
+      proofStepVerified = true;
+    }
+  }
+
+  return proofStepVerified;
+}
+
+Object.assign(verifySubDerivation, {
+  verifyProofStep
+});

package/src/verify/ruleDerivation.js

@@ -1,149 +1,23 @@
 "use strict";
 
-import MetaproofStep from "../step/metaproof";
-import verifyPremises from "../verify/premises";
-import LocalMetaContext from "../context/localMeta";
-import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
-import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
+import verifyRuleProofStep from "../verify/ruleProofStep";
 
-import { assignAssignment } from "../utilities/assignments";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import { RULE_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { nodesQuery } from "../utilities/query";
 
-const childNodesQuery = nodesQuery("/ruleDerivation|ruleSubDerivation/*"),
-      premiseNodesQuery = nodesQuery("/ruleSubproof/premise"),
-      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
-      ruleSubDerivationNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation");
+const ruleProofStepNodesQuery = nodesQuery("/ruleDerivation/ruleProofStep|lastRuleProofStep");
 
 export default function verifyRuleDerivation(ruleDerivationNode, localMetaContext) {
   let ruleDerivationVerified;
 
-  const childNodes = childNodesQuery(ruleDerivationNode);
+  const ruleProofStepNodes = ruleProofStepNodesQuery(ruleDerivationNode);
 
-  ruleDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, localMetaContext);
+  ruleDerivationVerified = ruleProofStepNodes.every((ruleProofStepNode) => {
+    const ruleProofStepVerified = verifyRuleProofStep(ruleProofStepNode, localMetaContext);
 
-    if (childVerified) {
+    if (ruleProofStepVerified) {
       return true;
     }
   });
 
   return ruleDerivationVerified;
 }
-
-function verifyRuleSubDerivation(ruleSubDerivationNode, localMetaContext) {
-  let ruleSubDerivationVerified;
-
-  const childNodes = childNodesQuery(ruleSubDerivationNode);
-
-  ruleSubDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, localMetaContext);
-
-    if (childVerified) {
-      return true;
-    }
-  });
-
-  return ruleSubDerivationVerified;
-}
-
-function verifyRuleSubproof(ruleSubproofNode, localMetaContext) {
-  let ruleSubproofVerified = false;
-
-  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
-
-  const premises = [],
-        premiseNodes = premiseNodesQuery(ruleSubproofNode),
-        premisesVerified = verifyPremises(premiseNodes, premises, localMetaContext);
-
-  if (premisesVerified) {
-    const ruleSubDerivationNode = ruleSubDerivationNodeQuery(ruleSubproofNode),
-          ruleSubDerivationVerified = verifyRuleSubDerivation(ruleSubDerivationNode, localMetaContext);
-
-    if (ruleSubDerivationVerified) {
-      ruleSubproofVerified = true;
-    }
-  }
-
-  return ruleSubproofVerified;
-}
-
-function verifyChild(childNode, localMetaContext) {
-  let childVerified;
-
-  const childNodeRuleName = childNode.getRuleName();
-
-  switch (childNodeRuleName) {
-    case RULE_SUBPROOF_RULE_NAME: {
-      const ruleSubproofNode = childNode,  ///
-            ruleSubproofVerified = verifyRuleSubproof(ruleSubproofNode, localMetaContext);
-
-      if (ruleSubproofVerified) {
-        const metaproofStep = MetaproofStep.fromRuleSubproofNode(ruleSubproofNode);
-
-        localMetaContext.addMetaproofStep(metaproofStep);
-
-        childVerified = true;
-      }
-
-      break;
-    }
-
-    case QUALIFIED_METASTATEMENT_RULE_NAME: {
-      let qualifiedMetastatementVerified;
-
-      const derived = true,
-            assignments = [],
-            substitutions = null,
-            qualifiedMetastatementNode = childNode;  ///
-
-      qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, derived, localMetaContext);
-
-      if (qualifiedMetastatementVerified) {
-        const assignmentAssigned = assignAssignment(assignments, localMetaContext);
-
-        qualifiedMetastatementVerified = assignmentAssigned; ///
-      }
-
-      if (qualifiedMetastatementVerified) {
-        const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-              metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-        localMetaContext.addMetaproofStep(metaproofStep);
-
-        childVerified = qualifiedMetastatementVerified; ///
-      }
-
-      break;
-    }
-
-    case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
-      let unqualifiedMetastatementVerified;
-
-      const derived = true,
-            assignments = [],
-            unqualifiedMetastatementNode = childNode;  ///
-
-      unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
-
-      if (unqualifiedMetastatementVerified) {
-        const assignmentAssigned = assignAssignment(assignments, localMetaContext);
-
-        unqualifiedMetastatementVerified = assignmentAssigned; ///
-      }
-
-      if (unqualifiedMetastatementVerified) {
-        const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-              metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-        localMetaContext.addMetaproofStep(metaproofStep);
-
-        childVerified = true;
-      }
-
-      break;
-    }
-  }
-
-  return childVerified;
-}

package/src/verify/ruleProofStep.js

@@ -0,0 +1,99 @@
+"use strict";
+
+import MetaproofStep from "../step/metaproof";
+import verifyRuleSubproof from "../verify/ruleSubproof";
+import verifyRuleSubDerivation from "../verify/ruleSubDerivation";
+import verifyQualifiedStatement from "../verify/statement/qualified";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
+
+import { nodeQuery } from "../utilities/query";
+import { assignAssignment } from "../utilities/assignments";
+
+const ruleSubproofNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/ruleSubproof!"),
+      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
+      qualifiedStatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/qualifiedStatement!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/unqualifiedStatement!"),
+      qualifiedMetastatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/qualifiedMetastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/ruleProofStep|lastRuleProofStep/unqualifiedMetastatement!");
+
+export default function verifyRuleProofStep(ruleProofStepNode, localMetaContext) {
+  let ruleProofStepVerified = false;
+
+  const ruleSubproofNode = ruleSubproofNodeQuery(ruleProofStepNode),
+        qualifiedStatementNode = qualifiedStatementNodeQuery(ruleProofStepNode),
+        unqualifiedStatementNode = unqualifiedStatementNodeQuery(ruleProofStepNode),
+        qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(ruleProofStepNode),
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(ruleProofStepNode);
+
+  if (false) {
+    ///
+  } else if (ruleSubproofNode !== null) {
+    let ruleSubproofVerified;
+
+    ruleSubproofVerified = verifyRuleSubproof(ruleSubproofNode, localMetaContext);
+
+    if (ruleSubproofVerified) {
+      const metaproofStep = MetaproofStep.fromRuleSubproofNode(ruleSubproofNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      ruleProofStepVerified = true;
+    }
+  } else if (qualifiedStatementNode !== null) {
+    debugger
+  } else if (unqualifiedStatementNode !== null) {
+    debugger
+  } else if (qualifiedMetastatementNode !== null) {
+    let qualifiedMetastatementVerified;
+
+    const assignments = [],
+          substitutions = null;
+
+    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localMetaContext);
+
+    if (qualifiedMetastatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+
+      qualifiedMetastatementVerified = assignmentAssigned; ///
+    }
+
+    if (qualifiedMetastatementVerified) {
+      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      ruleProofStepVerified = qualifiedMetastatementVerified; ///
+    }
+  } else if (unqualifiedMetastatementNode !== null) {
+    let unqualifiedMetastatementVerified;
+
+    const derived = true,
+          assignments = [];
+
+    unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
+
+    if (unqualifiedMetastatementVerified) {
+      const assignmentAssigned = assignAssignment(assignments, localMetaContext);
+
+      unqualifiedMetastatementVerified = assignmentAssigned; ///
+    }
+
+    if (unqualifiedMetastatementVerified) {
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
+
+      localMetaContext.addMetaproofStep(metaproofStep);
+
+      ruleProofStepVerified = true;
+    }
+  }
+
+  return ruleProofStepVerified;
+}
+
+Object.assign(verifyRuleSubDerivation, {
+  verifyRuleProofStep
+});

package/src/verify/ruleSubDerivation.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import { nodesQuery } from "../utilities/query";
+
+const ruleProofStepNodesQuery = nodesQuery("/ruleSubDerivation/ruleProofStep|lastRuleProofStep");
+
+export default function verifyRuleSubDerivation(ruleSubDerivationNode, localMetaContext) {
+  let ruleSubDerivationVerified;
+
+  const ruleProofStepNodes = ruleProofStepNodesQuery(ruleSubDerivationNode);
+
+  ruleSubDerivationVerified = ruleProofStepNodes.every((ruleProofStepNode) => {
+    const { verifyRuleProofStep } = verifyRuleSubDerivation,
+          ruleProofStepVerified = verifyRuleProofStep(ruleProofStepNode, localMetaContext);
+
+    if (ruleProofStepVerified) {
+      return true;
+    }
+  });
+
+  return ruleSubDerivationVerified;
+}

package/src/verify/ruleSubproof.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import verifyPremises from "../verify/premises";
+import LocalMetaContext from "../context/localMeta";
+import verifyRuleSubDerivation from "../verify/ruleSubDerivation";
+
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const premiseNodesQuery = nodesQuery("/ruleSubproof/premise"),
+      ruleSubDerivationNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation");
+
+export default function verifyRuleSubproof(ruleSubproofNode, localMetaContext) {
+  let ruleSubproofVerified = false;
+
+  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
+
+  const premises = [],
+        premiseNodes = premiseNodesQuery(ruleSubproofNode),
+        premisesVerified = verifyPremises(premiseNodes, premises, localMetaContext);
+
+  if (premisesVerified) {
+    const ruleSubDerivationNode = ruleSubDerivationNodeQuery(ruleSubproofNode),
+          ruleSubDerivationVerified = verifyRuleSubDerivation(ruleSubDerivationNode, localMetaContext);
+
+    if (ruleSubDerivationVerified) {
+      ruleSubproofVerified = true;
+    }
+  }
+
+  return ruleSubproofVerified;
+}
+