occam-verify-cli 0.0.919 → 0.0.921

package/src/verify/metastatementAsContainedAssertion.js

@@ -0,0 +1,127 @@
+"use strict";
+
+import metaLevelNodeVerifier from "../verifier/node/metaLevel";
+
+import { CONTAINED } from "../constants";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+import { isMetastatementNegated } from "../utilities/verify";
+
+const termNodeQuery = nodeQuery("/metastatement/term!"),
+      operatorTerminalNodesQuery = nodesQuery("/metastatement/@operator"),
+      metastatementTermNodesQuery = nodesQuery("/metastatement/metastatement//term");
+
+export default function verifyMetastatementAsContainedAssertion(metastatementNode, assignments, derived, localContext) {
+  let metastatementVerifiedAsContainedAssertion;
+
+  const metastatementContainedAssertion = isMetastatementContainedAssertion(metastatementNode);
+
+  if (metastatementContainedAssertion) {
+    const metastatementString = localContext.nodeAsString(metastatementNode);
+
+    localContext.trace(`Verifying the '${metastatementString}' metastatement as a contained assertion...`, metastatementNode);
+
+    const metastatementFunctions = [
+      verifyMetastatementAsDerivedContainedAssertion,
+      verifyMetastatementAsStatedContainedAssertion
+    ];
+
+    metastatementVerifiedAsContainedAssertion = metastatementFunctions.some((metastatementFunction) => {
+      const metastatementVerifiedAsContainedAssertion = metastatementFunction(metastatementNode, assignments, derived, localContext);
+
+      if (metastatementVerifiedAsContainedAssertion) {
+        return true;
+      }
+    });
+
+    if (metastatementVerifiedAsContainedAssertion) {
+      localContext.debug(`...verified the '${metastatementString}' metastatement as a contained assertion.`, metastatementNode);
+    }
+  }
+
+  return metastatementVerifiedAsContainedAssertion;
+}
+
+function verifyMetastatementAsDerivedContainedAssertion(metastatementNode, assignments, derived, localContext) {
+  let metastatementVerifiedAsDefinedContainedAssertion = false;
+
+  if (derived) {
+    const metastatementString = localContext.nodeAsString(metastatementNode);
+
+    localContext.trace(`Verifying the derived '${metastatementString}' metastatement as a contained assertion...`, metastatementNode);
+
+    const metastatementNegated = isMetastatementNegated(metastatementNode),
+          negated = metastatementNegated,
+          termNode = termNodeQuery(metastatementNode),
+          metastatementTermNodes = metastatementTermNodesQuery(metastatementNode),
+          termNodeMatchesMetaArgumentTermNode = metastatementTermNodes.some((metastatementTermNode) => {
+            const termNodeMatchesMetaArgumentTermNode = termNode.match(metastatementTermNode);
+
+            if (termNodeMatchesMetaArgumentTermNode) {
+              return true;
+            }
+          });
+
+    if (!negated) {
+      if (termNodeMatchesMetaArgumentTermNode) {
+        metastatementVerifiedAsDefinedContainedAssertion = true;
+      }
+    }
+
+    if (negated) {
+      if (!termNodeMatchesMetaArgumentTermNode) {
+        metastatementVerifiedAsDefinedContainedAssertion = true;
+      }
+    }
+
+    if (metastatementVerifiedAsDefinedContainedAssertion) {
+      localContext.debug(`...verified the derived '${metastatementString}' metastatement as a contained assertion.`, metastatementNode);
+    }
+  }
+
+  return metastatementVerifiedAsDefinedContainedAssertion;
+}
+
+function verifyMetastatementAsStatedContainedAssertion(metastatementNode, assignments, derived, localContext) {
+  let metastatementVerifiedAsStatedContainedAssertion = false;
+
+  if (!derived) {
+    const metastatementString = localContext.nodeAsString(metastatementNode);
+
+    localContext.trace(`Verifying the stated '${metastatementString}' metastatement as a contained assertion...`, metastatementNode);
+
+    const intrinsicLevel = localContext.isIntrinsicLevel();
+
+    if (intrinsicLevel) {
+      localContext.debug(`The stated '${metastatementString}' metastatement as a contained assertion cannot be verified at intrinsic level.`, metastatementNode);
+    } else {
+      const nonTerminalNode = metastatementNode, ///
+            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      metastatementVerifiedAsStatedContainedAssertion = nonTerminalNodeVerified; ///
+    }
+
+    if (metastatementVerifiedAsStatedContainedAssertion) {
+      localContext.debug(`...verified the stated '${metastatementString}' metastatement as a contained assertion.`, metastatementNode);
+    }
+  }
+
+  return metastatementVerifiedAsStatedContainedAssertion;
+}
+
+export function isMetastatementContainedAssertion(metastatementNode) {
+  const operatorTerminalNodes = operatorTerminalNodesQuery(metastatementNode),
+        metastatementContainedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
+          const content = operatorTerminalNode.getContent(),
+                contentContained = (content === CONTAINED);
+
+          if (contentContained) {
+            return true;
+          }
+        });
+
+  return metastatementContainedAssertion;
+}

package/src/verify/metastatementAsDefinedAssertion.js

@@ -0,0 +1,156 @@
+"use strict";
+
+import verifyTerm from "./term";
+import metaLevelNodeVerifier from "../verifier/node/metaLevel";
+
+import { first } from "../utilities/array";
+import { DEFINED } from "../constants";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+import { isMetastatementNegated } from "../utilities/verify";
+
+const termNodeQuery = nodeQuery("/metastatement/term!"),
+      variableNodeQuery = nodeQuery("/metastatement/term/variable!"),
+      operatorTerminalNodesQuery = nodesQuery("/metastatement/@operator");
+
+export default function verifyMetastatementAsDefinedAssertion(metastatementNode, assignments, derived, localContext) {
+  let metastatementVerifiedAsDefinedAssertion = false;
+
+  const metastatementDefinedAssertion = isMetastatementDefinedAssertion(metastatementNode);
+
+  if (metastatementDefinedAssertion) {
+    const metastatementString = localContext.nodeAsString(metastatementNode);
+
+    localContext.trace(`Verifying the '${metastatementString}' metastatement as a defined assertion...`, metastatementNode);
+
+    const definedAssertionFunctions = [
+      verifyDerivedMetastatementAsDefinedAssertion,
+      verifyStatedMetastatementAsDefinedAssertion
+    ];
+
+    metastatementVerifiedAsDefinedAssertion = definedAssertionFunctions.some((definedAssertionFunction) => {
+      const metastatementVerifiedAsDefinedAssertion = definedAssertionFunction(metastatementNode, assignments, derived, localContext);
+
+      if (metastatementVerifiedAsDefinedAssertion) {
+        return true;
+      }
+    });
+
+    if (metastatementVerifiedAsDefinedAssertion) {
+      localContext.debug(`...verified the '${metastatementString}' metastatement as a defined assertion.`, metastatementNode);
+    }
+  }
+
+  return metastatementVerifiedAsDefinedAssertion;
+}
+
+function verifyDerivedMetastatementAsDefinedAssertion(metastatementNode, assignments, derived, localContext) {
+  let derivedMetastatementVerifiedAsDefeindAssertion = false;
+
+  if (derived) {
+    const metastatementString = localContext.nodeAsString(metastatementNode);
+
+    localContext.trace(`Verifying the derived '${metastatementString}' metastatement as a defined assertion...`, metastatementNode);
+
+    const metastatementNegated = isMetastatementNegated(metastatementNode),
+          variableNode = variableNodeQuery(metastatementNode),
+          termNode = termNodeQuery(metastatementNode);
+
+    if (false) {
+      ///
+    } else if (variableNode !== null) {
+      const variable = localContext.findVariableByVariableNode(variableNode);
+
+      if (variable !== null) {
+        const variableDefined = localContext.isVariableDefined(variable);
+
+        if (!metastatementNegated) {
+          if (variableDefined) {
+            derivedMetastatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+
+        if (metastatementNegated) {
+          if (!variableDefined) {
+            derivedMetastatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+      }
+    } else if (termNode !== null) {
+      const terms = [],
+            termVerified = verifyTerm(termNode, terms, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      if (termVerified) {
+        const firstTerm = first(terms),
+              term = firstTerm, ///
+              termGrounded = localContext.isTermGrounded(term);
+
+        if (!metastatementNegated) {
+          if (termGrounded) {
+            derivedMetastatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+
+        if (metastatementNegated) {
+          if (!termGrounded) {
+            derivedMetastatementVerifiedAsDefeindAssertion = true;
+          }
+        }
+      }
+    }
+
+    if (derivedMetastatementVerifiedAsDefeindAssertion) {
+      localContext.debug(`...verified the derived '${metastatementString}' metastatement as a defined assertion.`, metastatementNode);
+    }
+  }
+
+  return derivedMetastatementVerifiedAsDefeindAssertion;
+}
+
+function verifyStatedMetastatementAsDefinedAssertion(metastatementNode, assignments, derived, localContext) {
+  let statedMetastatementVerifiedAsDefinedAssertion = false;
+
+  if (!derived) {
+    const metastatementString = localContext.nodeAsString(metastatementNode);
+
+    localContext.trace(`Verifying the stated '${metastatementString}' metastatement as a defined assertion...`, metastatementNode);
+
+    const intrinsicLevel = localContext.isIntrinsicLevel();
+
+    if (intrinsicLevel) {
+      localContext.debug(`The stated '${metastatementString}' metastatement as a defined assertion cannot be verified at intrinsic level.`, metastatementNode);
+    } else {
+      const nonTerminalNode = metastatementNode, ///
+            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+              const verifiedAhead = true;
+
+              return verifiedAhead;
+            });
+
+      statedMetastatementVerifiedAsDefinedAssertion = nonTerminalNodeVerified; ///
+    }
+
+    if (statedMetastatementVerifiedAsDefinedAssertion) {
+      localContext.debug(`...verified the stated '${metastatementString}' metastatement as a defined assertion.`, metastatementNode);
+    }
+  }
+
+  return statedMetastatementVerifiedAsDefinedAssertion;
+}
+
+export function isMetastatementDefinedAssertion(metastatementNode) {
+  const operatorTerminalNodes = operatorTerminalNodesQuery(metastatementNode),
+        metastatementDefinedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
+          const content = operatorTerminalNode.getContent(),
+                contentDefined = (content === DEFINED);
+
+          if (contentDefined) {
+            return true;
+          }
+        });
+
+  return metastatementDefinedAssertion;
+}

package/src/verify/metatheorem.js

@@ -43,7 +43,8 @@ export default function verifyMetatheorem(metatheoremNode, fileContext) {
         const metaproofNode = metaproofNodeQuery(metatheoremNode),
               firstMetaConsequent = first(metaConsequents),
               metaConsequent = firstMetaConsequent, ///
-              metaproofVerified = verifyMetaproof(metaproofNode, metaConsequent, substitutions, localContext);
+              metastatementNode = metaConsequent.getMetastatementNode(),
+              metaproofVerified = verifyMetaproof(metaproofNode, metastatementNode, substitutions, localContext);
 
         if (metaproofVerified) {
           const metatheorem = Metatheorem.fromLabelsMetaSuppositionsMetaConsequentSubstitutionsAndFileContext(labels, metaSuppositions, metaConsequent, substitutions, fileContext);

package/src/verify/premise.js

@@ -41,8 +41,7 @@ export default function verifyPremise(premiseNode, premises, localContext) {
           unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
 
     if (unqualifiedMetastatementVerified) {
-      const localContext = localContext,  ///
-            assignmentAssigned = assignAssignment(assignments, localContext);
+      const assignmentAssigned = assignAssignment(assignments, localContext);
 
       premiseVerified = assignmentAssigned; ///
     }

package/src/verify/rule.js

@@ -3,7 +3,7 @@
 import Rule from "../rule";
 import verifyLabels from "../verify/labels";
 import verifyPremises from "../verify/premises";
-import verifyRuleProof from "../verify/ruleProof";
+import verifyMetaproof from "../verify/metaproof";
 import verifyConclusion from "../verify/conclusion";
 import MetaLevelLocalContext from "../context/local/metaLevel";
 
@@ -12,7 +12,7 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const labelNodesQuery = nodesQuery("/rule/label"),
       premisesNodeQuery = nodesQuery("/rule/premise"),
-      ruleProofNodeQuery = nodeQuery("/rule/ruleProof!"),
+      metaproofNodeQuery = nodeQuery("/rule/metaproof!"),
       conclusionNodeQuery = nodeQuery("/rule/conclusion!");
 
 export default function verifyRule(ruleNode, fileContext) {
@@ -39,17 +39,20 @@ export default function verifyRule(ruleNode, fileContext) {
             conclusionVerified = verifyConclusion(conclusionNode, conclusions, localContext);
 
       if (conclusionVerified) {
-        const ruleProofNode = ruleProofNodeQuery(ruleNode),
-              firstConclusion = first(conclusions),
+        let metaproofVerified = true; ///
+
+        const firstConclusion = first(conclusions),
+              metaproofNode = metaproofNodeQuery(ruleNode),
               conclusion = firstConclusion; ///
 
-        let ruleProofVerified = true; ///
+        if (metaproofNode !== null) {
+          const substitutions = [],
+                metastatementNode = conclusion.getMetastatementNode();
 
-        if (ruleProofNode !== null) {
-          ruleProofVerified = verifyRuleProof(ruleProofNode, conclusion, localContext);
+          metaproofVerified = verifyMetaproof(metaproofNode, metastatementNode, substitutions, localContext);
         }
 
-        if (ruleProofVerified) {
+        if (metaproofVerified) {
           const rule = Rule.fromLabelsPremisesConclusionAndFileContext(labels, premises, conclusion, fileContext);
 
           fileContext.addRule(rule);

package/src/verify/statementAsContainedAssertion.js

@@ -6,9 +6,9 @@ import { CONTAINED } from "../constants";
 import { isStatementNegated } from "../utilities/verify";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const variableNodeQuery = nodeQuery("/statement/term/variable!"),
-      operatorTerminalNodesQuery = nodesQuery("/statement/@operator"),
-      statementVariableNodesQuery = nodesQuery("/statement/metaArgument/statement//variable");
+const termNodeQuery = nodeQuery("/statement/term!"),
+      statementTermNodesQuery = nodesQuery("/statement/metaArgument/statement//term"),
+      operatorTerminalNodesQuery = nodesQuery("/statement/@operator");
 
 export default function verifyStatementAsContainedAssertion(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsContainedAssertion;
@@ -50,31 +50,26 @@ function verifyStatementAsDerivedContainedAssertion(statementNode, assignments,
     localContext.trace(`Verifying the derived '${statementString}' statement as a contained assertion...`, statementNode);
 
     const statementNegated = isStatementNegated(statementNode),
-          variableNode = variableNodeQuery(statementNode),
-          negated = statementNegated;  ///
-
-    if (false) {
-      ///
-    } else if (variableNode !== null) {
-      const statementVariableNodes = statementVariableNodesQuery(statementNode),
-            variableNodeMatchesMetaArgumentVariableNode = statementVariableNodes.some((statementVariableNode) => {
-              const variableNodeMatchesMetaArgumentVariableNode = variableNode.match(statementVariableNode);
-
-              if (variableNodeMatchesMetaArgumentVariableNode) {
-                return true;
-              }
-            });
-
-      if (!negated) {
-        if (variableNodeMatchesMetaArgumentVariableNode) {
-          statementVerifiedAsDefinedContainedAssertion = true;
-        }
+          termNode = termNodeQuery(statementNode),
+          negated = statementNegated, ///
+          statementTermNodes = statementTermNodesQuery(statementNode),
+          termNodeMatchesMetaArgumentVariableNode = statementTermNodes.some((statementTermNode) => {
+            const termNodeMatchesMetaArgumentVariableNode = termNode.match(statementTermNode);
+
+            if (termNodeMatchesMetaArgumentVariableNode) {
+              return true;
+            }
+          });
+
+    if (!negated) {
+      if (termNodeMatchesMetaArgumentVariableNode) {
+        statementVerifiedAsDefinedContainedAssertion = true;
       }
+    }
 
-      if (negated) {
-        if (!variableNodeMatchesMetaArgumentVariableNode) {
-          statementVerifiedAsDefinedContainedAssertion = true;
-        }
+    if (negated) {
+      if (!termNodeMatchesMetaArgumentVariableNode) {
+        statementVerifiedAsDefinedContainedAssertion = true;
       }
     }
 

package/lib/verify/ruleDerivation.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyRuleDerivation;
-    }
-});
-var _ruleProofStep = /*#__PURE__*/ _interop_require_default(require("../verify/ruleProofStep"));
-var _query = require("../utilities/query");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var ruleProofStepNodesQuery = (0, _query.nodesQuery)("/ruleDerivation/ruleProofStep|lastRuleProofStep");
-function verifyRuleDerivation(ruleDerivationNode, localContext) {
-    var ruleDerivationVerified;
-    var ruleProofStepNodes = ruleProofStepNodesQuery(ruleDerivationNode);
-    ruleDerivationVerified = ruleProofStepNodes.every(function(ruleProofStepNode) {
-        var ruleProofStepVerified = (0, _ruleProofStep.default)(ruleProofStepNode, localContext);
-        if (ruleProofStepVerified) {
-            return true;
-        }
-    });
-    return ruleDerivationVerified;
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJpZnkvcnVsZURlcml2YXRpb24uanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCB2ZXJpZnlSdWxlUHJvb2ZTdGVwIGZyb20gXCIuLi92ZXJpZnkvcnVsZVByb29mU3RlcFwiO1xuXG5pbXBvcnQgeyBub2Rlc1F1ZXJ5IH0gZnJvbSBcIi4uL3V0aWxpdGllcy9xdWVyeVwiO1xuXG5jb25zdCBydWxlUHJvb2ZTdGVwTm9kZXNRdWVyeSA9IG5vZGVzUXVlcnkoXCIvcnVsZURlcml2YXRpb24vcnVsZVByb29mU3RlcHxsYXN0UnVsZVByb29mU3RlcFwiKTtcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gdmVyaWZ5UnVsZURlcml2YXRpb24ocnVsZURlcml2YXRpb25Ob2RlLCBsb2NhbENvbnRleHQpIHtcbiAgbGV0IHJ1bGVEZXJpdmF0aW9uVmVyaWZpZWQ7XG5cbiAgY29uc3QgcnVsZVByb29mU3RlcE5vZGVzID0gcnVsZVByb29mU3RlcE5vZGVzUXVlcnkocnVsZURlcml2YXRpb25Ob2RlKTtcblxuICBydWxlRGVyaXZhdGlvblZlcmlmaWVkID0gcnVsZVByb29mU3RlcE5vZGVzLmV2ZXJ5KChydWxlUHJvb2ZTdGVwTm9kZSkgPT4ge1xuICAgIGNvbnN0IHJ1bGVQcm9vZlN0ZXBWZXJpZmllZCA9IHZlcmlmeVJ1bGVQcm9vZlN0ZXAocnVsZVByb29mU3RlcE5vZGUsIGxvY2FsQ29udGV4dCk7XG5cbiAgICBpZiAocnVsZVByb29mU3RlcFZlcmlmaWVkKSB7XG4gICAgICByZXR1cm4gdHJ1ZTtcbiAgICB9XG4gIH0pO1xuXG4gIHJldHVybiBydWxlRGVyaXZhdGlvblZlcmlmaWVkO1xufVxuIl0sIm5hbWVzIjpbInZlcmlmeVJ1bGVEZXJpdmF0aW9uIiwicnVsZVByb29mU3RlcE5vZGVzUXVlcnkiLCJub2Rlc1F1ZXJ5IiwicnVsZURlcml2YXRpb25Ob2RlIiwibG9jYWxDb250ZXh0IiwicnVsZURlcml2YXRpb25WZXJpZmllZCIsInJ1bGVQcm9vZlN0ZXBOb2RlcyIsImV2ZXJ5IiwicnVsZVByb29mU3RlcE5vZGUiLCJydWxlUHJvb2ZTdGVwVmVyaWZpZWQiLCJ2ZXJpZnlSdWxlUHJvb2ZTdGVwIl0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFRQTs7O2VBQXdCQTs7O29FQU5RO3FCQUVMOzs7Ozs7QUFFM0IsSUFBTUMsMEJBQTBCQyxJQUFBQSxpQkFBVSxFQUFDO0FBRTVCLFNBQVNGLHFCQUFxQkcsa0JBQWtCLEVBQUVDLFlBQVk7SUFDM0UsSUFBSUM7SUFFSixJQUFNQyxxQkFBcUJMLHdCQUF3QkU7SUFFbkRFLHlCQUF5QkMsbUJBQW1CQyxLQUFLLENBQUMsU0FBQ0M7UUFDakQsSUFBTUMsd0JBQXdCQyxJQUFBQSxzQkFBbUIsRUFBQ0YsbUJBQW1CSjtRQUVyRSxJQUFJSyx1QkFBdUI7WUFDekIsT0FBTztRQUNUO0lBQ0Y7SUFFQSxPQUFPSjtBQUNUIn0=

package/lib/verify/ruleProof.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyRuleProof;
-    }
-});
-var _ruleDerivation = /*#__PURE__*/ _interop_require_default(require("../verify/ruleDerivation"));
-var _metaLevel = /*#__PURE__*/ _interop_require_default(require("../context/local/metaLevel"));
-var _query = require("../utilities/query");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var ruleDerivationNodeQuery = (0, _query.nodeQuery)("/ruleProof/ruleDerivation!");
-function verifyRuleProof(ruleProofNode, conclusion, localContext) {
-    var ruleProofVerified = false;
-    var metaLevelLocalContext = _metaLevel.default.fromLocalContext(localContext);
-    localContext = metaLevelLocalContext; ///
-    var ruleDerivationNode = ruleDerivationNodeQuery(ruleProofNode), ruleDerivationVerified = (0, _ruleDerivation.default)(ruleDerivationNode, localContext);
-    if (ruleDerivationVerified) {
-        var lastMetaproofStep = localContext.getLastMetaproofStep(), metaproofStep = lastMetaproofStep, metastatementNode = metaproofStep.getMetastatementNode(), conclusionMetastatementNode = conclusion.getMetastatementNode(), metastatementNodeMatchConclusionMetastatementNode = metastatementNode.match(conclusionMetastatementNode);
-        ruleProofVerified = metastatementNodeMatchConclusionMetastatementNode; ///
-    }
-    return ruleProofVerified;
-}
-
-//# sourceMappingURL=data:application/json;base64,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

package/lib/verify/ruleProofStep.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyRuleProofStep;
-    }
-});
-var _metaproof = /*#__PURE__*/ _interop_require_default(require("../step/metaproof"));
-var _ruleSubproof = /*#__PURE__*/ _interop_require_default(require("../verify/ruleSubproof"));
-var _ruleSubDerivation = /*#__PURE__*/ _interop_require_default(require("../verify/ruleSubDerivation"));
-var _qualified = /*#__PURE__*/ _interop_require_default(require("../verify/statement/qualified"));
-var _unqualified = /*#__PURE__*/ _interop_require_default(require("../verify/statement/unqualified"));
-var _qualified1 = /*#__PURE__*/ _interop_require_default(require("../verify/metastatement/qualified"));
-var _unqualified1 = /*#__PURE__*/ _interop_require_default(require("../verify/metastatement/unqualified"));
-var _query = require("../utilities/query");
-var _assignments = require("../utilities/assignments");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var statementNodeQuery = (0, _query.nodeQuery)("/qualifiedStatement|unqualifiedStatement/statement!"), ruleSubproofNodeQuery = (0, _query.nodeQuery)("/ruleProofStep|lastRuleProofStep/ruleSubproof!"), metastatementNodeQuery = (0, _query.nodeQuery)("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"), qualifiedStatementNodeQuery = (0, _query.nodeQuery)("/ruleProofStep|lastRuleProofStep/qualifiedStatement!"), unqualifiedStatementNodeQuery = (0, _query.nodeQuery)("/ruleProofStep|lastRuleProofStep/unqualifiedStatement!"), qualifiedMetastatementNodeQuery = (0, _query.nodeQuery)("/ruleProofStep|lastRuleProofStep/qualifiedMetastatement!"), unqualifiedMetastatementNodeQuery = (0, _query.nodeQuery)("/ruleProofStep|lastRuleProofStep/unqualifiedMetastatement!");
-function verifyRuleProofStep(ruleProofStepNode, localContext) {
-    var ruleProofStepVerified = false;
-    var ruleSubproofNode = ruleSubproofNodeQuery(ruleProofStepNode), qualifiedStatementNode = qualifiedStatementNodeQuery(ruleProofStepNode), unqualifiedStatementNode = unqualifiedStatementNodeQuery(ruleProofStepNode), qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(ruleProofStepNode), unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(ruleProofStepNode);
-    if (false) {
-    ///
-    } else if (ruleSubproofNode !== null) {
-        var ruleSubproofVerified;
-        ruleSubproofVerified = (0, _ruleSubproof.default)(ruleSubproofNode, localContext);
-        if (ruleSubproofVerified) {
-            var metaproofStep = _metaproof.default.fromRuleSubproofNode(ruleSubproofNode);
-            localContext.addMetaproofStep(metaproofStep);
-            ruleProofStepVerified = true;
-        }
-    } else if (qualifiedStatementNode !== null) {
-        var qualifiedStatementVerified;
-        var assignments = [];
-        qualifiedStatementVerified = (0, _qualified.default)(qualifiedStatementNode, assignments, localContext);
-        if (qualifiedStatementVerified) {
-            var assignmentAssigned = (0, _assignments.assignAssignment)(assignments, localContext);
-            qualifiedStatementVerified = assignmentAssigned; ///
-        }
-        if (qualifiedStatementVerified) {
-            var statementNode = statementNodeQuery(qualifiedStatementNode), metaproofStep1 = _metaproof.default.fromStatementNode(statementNode);
-            localContext.addMetaproofStep(metaproofStep1);
-            ruleProofStepVerified = true;
-        }
-    } else if (unqualifiedStatementNode !== null) {
-        var unqualifiedStatementVerified;
-        var derived = true, assignments1 = [];
-        unqualifiedStatementVerified = (0, _unqualified.default)(unqualifiedStatementNode, assignments1, derived, localContext);
-        if (unqualifiedStatementVerified) {
-            var assignmentAssigned1 = (0, _assignments.assignAssignment)(assignments1, localContext);
-            unqualifiedStatementVerified = assignmentAssigned1; ///
-        }
-        if (unqualifiedStatementVerified) {
-            var statementNode1 = statementNodeQuery(unqualifiedStatementNode), metaproofStep2 = _metaproof.default.fromStatementNode(statementNode1);
-            localContext.addMetaproofStep(metaproofStep2);
-            ruleProofStepVerified = unqualifiedStatementVerified; ///
-        }
-    } else if (qualifiedMetastatementNode !== null) {
-        var qualifiedMetastatementVerified;
-        var assignments2 = [], substitutions = null;
-        qualifiedMetastatementVerified = (0, _qualified1.default)(qualifiedMetastatementNode, substitutions, assignments2, localContext);
-        if (qualifiedMetastatementVerified) {
-            var assignmentAssigned2 = (0, _assignments.assignAssignment)(assignments2, localContext);
-            qualifiedMetastatementVerified = assignmentAssigned2; ///
-        }
-        if (qualifiedMetastatementVerified) {
-            var metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode), metaproofStep3 = _metaproof.default.fromMetastatementNode(metastatementNode);
-            localContext.addMetaproofStep(metaproofStep3);
-            ruleProofStepVerified = qualifiedMetastatementVerified; ///
-        }
-    } else if (unqualifiedMetastatementNode !== null) {
-        var unqualifiedMetastatementVerified;
-        var derived1 = true, assignments3 = [];
-        unqualifiedMetastatementVerified = (0, _unqualified1.default)(unqualifiedMetastatementNode, assignments3, derived1, localContext);
-        if (unqualifiedMetastatementVerified) {
-            var assignmentAssigned3 = (0, _assignments.assignAssignment)(assignments3, localContext);
-            unqualifiedMetastatementVerified = assignmentAssigned3; ///
-        }
-        if (unqualifiedMetastatementVerified) {
-            var metastatementNode1 = metastatementNodeQuery(unqualifiedMetastatementNode), metaproofStep4 = _metaproof.default.fromMetastatementNode(metastatementNode1);
-            localContext.addMetaproofStep(metaproofStep4);
-            ruleProofStepVerified = true;
-        }
-    }
-    return ruleProofStepVerified;
-}
-Object.assign(_ruleSubDerivation.default, {
-    verifyRuleProofStep: verifyRuleProofStep
-});
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/ruleProofStep.js"],"sourcesContent":["\"use strict\";\n\nimport MetaproofStep from \"../step/metaproof\";\nimport verifyRuleSubproof from \"../verify/ruleSubproof\";\nimport verifyRuleSubDerivation from \"../verify/ruleSubDerivation\";\nimport verifyQualifiedStatement from \"../verify/statement/qualified\";\nimport verifyUnqualifiedStatement from \"../verify/statement/unqualified\";\nimport verifyQualifiedMetastatement from \"../verify/metastatement/qualified\";\nimport verifyUnqualifiedMetastatement from \"../verify/metastatement/unqualified\";\n\nimport { nodeQuery } from \"../utilities/query\";\nimport { assignAssignment } from \"../utilities/assignments\";\n\nconst statementNodeQuery = nodeQuery(\"/qualifiedStatement|unqualifiedStatement/statement!\"),\n      ruleSubproofNodeQuery = nodeQuery(\"/ruleProofStep|lastRuleProofStep/ruleSubproof!\"),\n      metastatementNodeQuery = nodeQuery(\"/qualifiedMetastatement|unqualifiedMetastatement/metastatement!\"),\n      qualifiedStatementNodeQuery = nodeQuery(\"/ruleProofStep|lastRuleProofStep/qualifiedStatement!\"),\n      unqualifiedStatementNodeQuery = nodeQuery(\"/ruleProofStep|lastRuleProofStep/unqualifiedStatement!\"),\n      qualifiedMetastatementNodeQuery = nodeQuery(\"/ruleProofStep|lastRuleProofStep/qualifiedMetastatement!\"),\n      unqualifiedMetastatementNodeQuery = nodeQuery(\"/ruleProofStep|lastRuleProofStep/unqualifiedMetastatement!\");\n\nexport default function verifyRuleProofStep(ruleProofStepNode, localContext) {\n  let ruleProofStepVerified = false;\n\n  const ruleSubproofNode = ruleSubproofNodeQuery(ruleProofStepNode),\n        qualifiedStatementNode = qualifiedStatementNodeQuery(ruleProofStepNode),\n        unqualifiedStatementNode = unqualifiedStatementNodeQuery(ruleProofStepNode),\n        qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(ruleProofStepNode),\n        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(ruleProofStepNode);\n\n  if (false) {\n    ///\n  } else if (ruleSubproofNode !== null) {\n    let ruleSubproofVerified;\n\n    ruleSubproofVerified = verifyRuleSubproof(ruleSubproofNode, localContext);\n\n    if (ruleSubproofVerified) {\n      const metaproofStep = MetaproofStep.fromRuleSubproofNode(ruleSubproofNode);\n\n      localContext.addMetaproofStep(metaproofStep);\n\n      ruleProofStepVerified = true;\n    }\n  } else if (qualifiedStatementNode !== null) {\n    let qualifiedStatementVerified;\n\n    const assignments = [];\n\n    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);\n\n    if (qualifiedStatementVerified) {\n      const assignmentAssigned = assignAssignment(assignments, localContext);\n\n      qualifiedStatementVerified = assignmentAssigned; ///\n    }\n\n    if (qualifiedStatementVerified) {\n      const statementNode = statementNodeQuery(qualifiedStatementNode),\n            metaproofStep = MetaproofStep.fromStatementNode(statementNode);\n\n      localContext.addMetaproofStep(metaproofStep);\n\n      ruleProofStepVerified = true;\n    }\n  } else if (unqualifiedStatementNode !== null) {\n    let unqualifiedStatementVerified;\n\n    const derived = true,\n          assignments = [];\n\n    unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);\n\n    if (unqualifiedStatementVerified) {\n      const assignmentAssigned = assignAssignment(assignments, localContext);\n\n      unqualifiedStatementVerified = assignmentAssigned; ///\n    }\n\n    if (unqualifiedStatementVerified) {\n      const statementNode = statementNodeQuery(unqualifiedStatementNode),\n            metaproofStep = MetaproofStep.fromStatementNode(statementNode);\n\n      localContext.addMetaproofStep(metaproofStep);\n\n      ruleProofStepVerified = unqualifiedStatementVerified; ///\n    }\n  } else if (qualifiedMetastatementNode !== null) {\n    let qualifiedMetastatementVerified;\n\n    const assignments = [],\n          substitutions = null;\n\n    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localContext);\n\n    if (qualifiedMetastatementVerified) {\n      const assignmentAssigned = assignAssignment(assignments, localContext);\n\n      qualifiedMetastatementVerified = assignmentAssigned; ///\n    }\n\n    if (qualifiedMetastatementVerified) {\n      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),\n            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);\n\n      localContext.addMetaproofStep(metaproofStep);\n\n      ruleProofStepVerified = qualifiedMetastatementVerified; ///\n    }\n  } else if (unqualifiedMetastatementNode !== null) {\n    let unqualifiedMetastatementVerified;\n\n    const derived = true,\n          assignments = [];\n\n    unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);\n\n    if (unqualifiedMetastatementVerified) {\n      const assignmentAssigned = assignAssignment(assignments, localContext);\n\n      unqualifiedMetastatementVerified = assignmentAssigned; ///\n    }\n\n    if (unqualifiedMetastatementVerified) {\n      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),\n            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);\n\n      localContext.addMetaproofStep(metaproofStep);\n\n      ruleProofStepVerified = true;\n    }\n  }\n\n  return ruleProofStepVerified;\n}\n\nObject.assign(verifyRuleSubDerivation, {\n  verifyRuleProofStep\n});\n"],"names":["verifyRuleProofStep","statementNodeQuery","nodeQuery","ruleSubproofNodeQuery","metastatementNodeQuery","qualifiedStatementNodeQuery","unqualifiedStatementNodeQuery","qualifiedMetastatementNodeQuery","unqualifiedMetastatementNodeQuery","ruleProofStepNode","localContext","ruleProofStepVerified","ruleSubproofNode","qualifiedStatementNode","unqualifiedStatementNode","qualifiedMetastatementNode","unqualifiedMetastatementNode","ruleSubproofVerified","verifyRuleSubproof","metaproofStep","MetaproofStep","fromRuleSubproofNode","addMetaproofStep","qualifiedStatementVerified","assignments","verifyQualifiedStatement","assignmentAssigned","assignAssignment","statementNode","fromStatementNode","unqualifiedStatementVerified","derived","verifyUnqualifiedStatement","qualifiedMetastatementVerified","substitutions","verifyQualifiedMetastatement","metastatementNode","fromMetastatementNode","unqualifiedMetastatementVerified","verifyUnqualifiedMetastatement","Object","assign","verifyRuleSubDerivation"],"mappings":"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"}

package/lib/verify/ruleSubDerivation.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyRuleSubDerivation;
-    }
-});
-var _query = require("../utilities/query");
-var ruleProofStepNodesQuery = (0, _query.nodesQuery)("/ruleSubDerivation/ruleProofStep|lastRuleProofStep");
-function verifyRuleSubDerivation(ruleSubDerivationNode, localContext) {
-    var ruleSubDerivationVerified;
-    var ruleProofStepNodes = ruleProofStepNodesQuery(ruleSubDerivationNode);
-    ruleSubDerivationVerified = ruleProofStepNodes.every(function(ruleProofStepNode) {
-        var verifyRuleProofStep = verifyRuleSubDerivation.verifyRuleProofStep, ruleProofStepVerified = verifyRuleProofStep(ruleProofStepNode, localContext);
-        if (ruleProofStepVerified) {
-            return true;
-        }
-    });
-    return ruleSubDerivationVerified;
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJpZnkvcnVsZVN1YkRlcml2YXRpb24uanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCB7IG5vZGVzUXVlcnkgfSBmcm9tIFwiLi4vdXRpbGl0aWVzL3F1ZXJ5XCI7XG5cbmNvbnN0IHJ1bGVQcm9vZlN0ZXBOb2Rlc1F1ZXJ5ID0gbm9kZXNRdWVyeShcIi9ydWxlU3ViRGVyaXZhdGlvbi9ydWxlUHJvb2ZTdGVwfGxhc3RSdWxlUHJvb2ZTdGVwXCIpO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiB2ZXJpZnlSdWxlU3ViRGVyaXZhdGlvbihydWxlU3ViRGVyaXZhdGlvbk5vZGUsIGxvY2FsQ29udGV4dCkge1xuICBsZXQgcnVsZVN1YkRlcml2YXRpb25WZXJpZmllZDtcblxuICBjb25zdCBydWxlUHJvb2ZTdGVwTm9kZXMgPSBydWxlUHJvb2ZTdGVwTm9kZXNRdWVyeShydWxlU3ViRGVyaXZhdGlvbk5vZGUpO1xuXG4gIHJ1bGVTdWJEZXJpdmF0aW9uVmVyaWZpZWQgPSBydWxlUHJvb2ZTdGVwTm9kZXMuZXZlcnkoKHJ1bGVQcm9vZlN0ZXBOb2RlKSA9PiB7XG4gICAgY29uc3QgeyB2ZXJpZnlSdWxlUHJvb2ZTdGVwIH0gPSB2ZXJpZnlSdWxlU3ViRGVyaXZhdGlvbixcbiAgICAgICAgICBydWxlUHJvb2ZTdGVwVmVyaWZpZWQgPSB2ZXJpZnlSdWxlUHJvb2ZTdGVwKHJ1bGVQcm9vZlN0ZXBOb2RlLCBsb2NhbENvbnRleHQpO1xuXG4gICAgaWYgKHJ1bGVQcm9vZlN0ZXBWZXJpZmllZCkge1xuICAgICAgcmV0dXJuIHRydWU7XG4gICAgfVxuICB9KTtcblxuICByZXR1cm4gcnVsZVN1YkRlcml2YXRpb25WZXJpZmllZDtcbn1cbiJdLCJuYW1lcyI6WyJ2ZXJpZnlSdWxlU3ViRGVyaXZhdGlvbiIsInJ1bGVQcm9vZlN0ZXBOb2Rlc1F1ZXJ5Iiwibm9kZXNRdWVyeSIsInJ1bGVTdWJEZXJpdmF0aW9uTm9kZSIsImxvY2FsQ29udGV4dCIsInJ1bGVTdWJEZXJpdmF0aW9uVmVyaWZpZWQiLCJydWxlUHJvb2ZTdGVwTm9kZXMiLCJldmVyeSIsInJ1bGVQcm9vZlN0ZXBOb2RlIiwidmVyaWZ5UnVsZVByb29mU3RlcCIsInJ1bGVQcm9vZlN0ZXBWZXJpZmllZCJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7K0JBTUE7OztlQUF3QkE7OztxQkFKRztBQUUzQixJQUFNQywwQkFBMEJDLElBQUFBLGlCQUFVLEVBQUM7QUFFNUIsU0FBU0Ysd0JBQXdCRyxxQkFBcUIsRUFBRUMsWUFBWTtJQUNqRixJQUFJQztJQUVKLElBQU1DLHFCQUFxQkwsd0JBQXdCRTtJQUVuREUsNEJBQTRCQyxtQkFBbUJDLEtBQUssQ0FBQyxTQUFDQztRQUNwRCxJQUFNLEFBQUVDLHNCQUF3QlQsd0JBQXhCUyxxQkFDRkMsd0JBQXdCRCxvQkFBb0JELG1CQUFtQko7UUFFckUsSUFBSU0sdUJBQXVCO1lBQ3pCLE9BQU87UUFDVDtJQUNGO0lBRUEsT0FBT0w7QUFDVCJ9