occam-verify-cli 0.0.922 → 0.0.924

package/src/metaSupposition.js

@@ -1,127 +0,0 @@
-"use strict";
-
-import LocalContext from "./context/local";
-import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
-
-import { match } from "./utilities/array";
-import { nodeAsString } from "./utilities/string";
-import { nodeQuery, nodesQuery } from "./utilities/query";
-import { statementNodeFromStatementString, metastatementNodeFromMetastatementString } from "./utilities/node";
-
-const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"),
-      subproofAssertionMetastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
-      metaSubproofMetaSuppositionMetastatementNodesQuery = nodesQuery("/metaSubproof/metaSupposition/unqualifiedMetastatement/metastatement!"),
-      metaSubproofLastMetpProofStepMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/lastMetpProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
-
-export default class MetaSupposition {
-  constructor(metastatementNode, statementNode) {
-    this.metastatementNode = metastatementNode;
-    this.statementNode = statementNode;
-  }
-
-  getMetastatementNode() {
-    return this.metastatementNode;
-  }
-
-  getStatementNode() {
-    return this.statementNode;
-  }
-
-  matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localContext) {
-    let matchesMetaSubproofNode = false;
-
-    if (this.metastatementNode !== null) {
-      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
-
-      if (subproofAssertionNode !== null) {
-        const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
-              metaSubproofLastMetpProofStepMetastatementNode = metaSubproofLastMetpProofStepMetastatementNodeQuery(metaSubproofNode),
-              metaSubproofMetastatementNodes = [
-                ...metaSubproofMetaSuppositionMetastatementNodes,
-                metaSubproofLastMetpProofStepMetastatementNode
-              ],
-              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
-
-        matchesMetaSubproofNode = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const fileContextA = fileContext, ///
-                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                localContextA = LocalContext.fromFileContext(fileContextA),  ///
-                localContextB = localContext,  ///
-                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return matchesMetaSubproofNode;
-  }
-
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext) {
-    let matchesMetastatementNode = false;
-
-    if (this.metastatementNode !== null) {
-      const fileContextA = fileContext, ///
-            nonTerminalNodeA = this.metastatementNode,  ///
-            nonTerminalNodeB = metastatementNode,  ///
-            localContextA = LocalContext.fromFileContext(fileContextA),  ///
-            localContextB = localContext,  ///
-            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-              const verifiedAhead = true;
-
-              return verifiedAhead;
-            });
-
-      matchesMetastatementNode = nonTerminalNodeVerified; ///
-    }
-
-    return matchesMetastatementNode;
-  }
-
-  toJSON(tokens) {
-    const metastatementString = nodeAsString(this.metastatementNode, tokens),
-          statementString = nodeAsString(this.statementNode, tokens),
-          metastatement = metastatementString, ///
-          statement = statementString, ///
-          json = {
-            metastatement,
-            statement
-          };
-
-    return json;
-  }
-
-  static fromStatementNode(statementNode) {
-    const metastatementNode = null,
-          metaSupposition = new MetaSupposition(metastatementNode, statementNode);
-
-    return metaSupposition;
-  }
-
-  static fromMetastatementNode(metastatementNode) {
-    const statementNode = null,
-          metaSupposition = new MetaSupposition(metastatementNode, statementNode);
-
-    return metaSupposition;
-  }
-
-  static fromJSONAndFileContext(json, fileContext) {
-    const { metastatement, statement } = json,
-          metastatementString = metastatement,  ///
-          statementString = statement,  ///
-          lexer = fileContext.getLexer(),
-          parser = fileContext.getParser(),
-          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
-          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
-          metaSupposition = new MetaSupposition(metastatementNode, statementNode);
-
-    return metaSupposition;
-  }
-}

package/src/node/metastatement/bracketed.js

@@ -1,9 +0,0 @@
-"use strict";
-
-import { metastatementNodeFromMetastatementString } from "../../utilities/node";
-
-const bracketedMetastatementString = "(A)";
-
-const bracketedMetastatementNode = metastatementNodeFromMetastatementString(bracketedMetastatementString);
-
-export default bracketedMetastatementNode;

package/src/step/metaproof.js

@@ -1,73 +0,0 @@
-"use strict";
-
-export default class MetaproofStep {
-  constructor(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode) {
-    this.statementNode = statementNode;
-    this.ruleSubproofNode = ruleSubproofNode;
-    this.metaSubproofNode = metaSubproofNode;
-    this.metastatementNode = metastatementNode;
-  }
-
-  getStatementNode() {
-    return this.statementNode;
-  }
-
-  getRuleSubproofNode() {
-    return this.ruleSubproofNode;
-  }
-
-  getMetaSubproofNode() {
-    return this.metaSubproofNode;
-  }
-
-  getMetastatementNode() {
-    return this.metastatementNode;
-  }
-
-  matchMetastatementNode(metastatementNode) {
-    let matchesMetastatementNode = false;
-
-    if (this.metastatementNode !== null) {
-      matchesMetastatementNode = this.metastatementNode.match(metastatementNode);
-    }
-
-    return matchesMetastatementNode;
-  }
-
-  static fromStatementNode(statementNode) {
-    const ruleSubproofNode = null,
-          metaSubproofNode = null,
-          metastatementNode = null,
-          metaproofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
-
-    return metaproofStep;
-  }
-
-  static fromRuleSubproofNode(ruleSubproofNode) {
-    const statementNode = null,
-          metaSubproofNode = null,
-          metastatementNode = null,
-          metaproofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
-
-    return metaproofStep;
-  }
-
-  static fromMetaSubproofNode(metaSubproofNode) {
-    const statementNode = null,
-          ruleSubproofNode = null,
-          metastatementNode = null,
-          metaproofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
-
-    return metaproofStep;
-
-  }
-
-  static fromMetastatementNode(metastatementNode) {
-    const statementNode = null,
-          ruleSubproofNode = null,
-          metaSubproofNode = null,
-          metaproofStep = new MetaproofStep(statementNode, ruleSubproofNode, metaSubproofNode, metastatementNode);
-
-    return metaproofStep;
-  }
-}

package/src/substitution/metastatementForMetavariable.js

@@ -1,90 +0,0 @@
-"use strict";
-
-import Substitution from "../substitution";
-
-import { nodeAsString } from "../utilities/string";
-import { bracketedMetastatementChildNodeFromMetastatementNode } from "../utilities/match";
-import { metavariableNodeFromMetavariableString, metastatementNodeFromMetastatementString } from "../utilities/node";
-
-export default class MetastatementForMetavariableSubstitution extends Substitution {
-  constructor(metavariableNode, metastatementNode) {
-    super();
-
-    this.metavariableNode = metavariableNode;
-    this.metastatementNode = metastatementNode;
-  }
-
-  getMetavariableNode() {
-    return this.metavariableNode;
-  }
-
-  getMetastatementNode() {
-    return this.metastatementNode;
-  }
-
-  matchMetavariableNode(metavariableNode) {
-    const matchesMetavariableNode = this.metavariableNode.match(metavariableNode);
-
-    return matchesMetavariableNode;
-  }
-
-  matchMetastatementNode(metastatementNode) {
-    let matchesMetastatementNode;
-
-    matchesMetastatementNode = this.metastatementNode.match(metastatementNode)
-
-    if (!matchesMetastatementNode) {
-      const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode);
-
-      if (bracketedMetastatementChildNode !== null) {
-        const metastatementNode = bracketedMetastatementChildNode; ///
-
-        matchesMetastatementNode = this.metastatementNode.match(metastatementNode);
-      }
-    }
-
-    return matchesMetastatementNode;
-  }
-
-  toJSON(tokens) {
-    const metavariableString = nodeAsString(this.metavariableNode, tokens),
-          metastatementString = nodeAsString(this.metastatementNode, tokens),
-          metavariable = metavariableString, ///
-          metastatement = metastatementString,  ///
-          json = {
-            metavariable,
-            metastatement
-          };
-
-    return json;
-  }
-
-  static fromJSONAndFileContext(json, fileContext) {
-    const { metavariable, metastatement } = json,
-          metavariableString = metavariable,  ///
-          metastatementString = metastatement,  ///
-          lexer = fileContext.getLexer(),
-          parser = fileContext.getParser(),
-          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
-          metavariableNode = metavariableNodeFromMetavariableString(metavariableString, lexer, parser),
-          metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metastatementNode, metavariableNode);
-
-    return metastatementForMetavariableSubstitution;
-  }
-
-  static fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode) {
-    let metastatementForMetavariableSubstitution;
-
-    metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableNode, metastatementNode);
-
-    const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode);
-
-    if (bracketedMetastatementChildNode !== null) {
-      const metastatementNode = bracketedMetastatementChildNode; ///
-
-      metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableNode, metastatementNode);
-    }
-
-    return metastatementForMetavariableSubstitution;
-  }
-}

package/src/verify/metaConsequent.js

@@ -1,61 +0,0 @@
-"use strict";
-
-import MetaConsequent from "../metaConsequent";
-import verifyUnqualifiedStatement from "./statement/unqualified";
-import verifyUnqualifiedMetastatement from "./metastatement/unqualified";
-
-import { nodeQuery } from "../utilities/query";
-
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
-      unqualifiedStatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedStatement!"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedMetastatement!");
-
-export default function verifyMetaConsequent(metaConsequentNode, metaConsequents, substitutions, localContext) {
-  let metaConsequentVerified = false;
-
-  const metaConsequentString = localContext.nodeAsString(metaConsequentNode);
-
-  localContext.trace(`Verifying the '${metaConsequentString}' meta-consequent...`, metaConsequentNode);
-
-  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(metaConsequentNode),
-        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaConsequentNode);
-
-  if (unqualifiedStatementNode !== null) {
-    const derived = false,
-          assignments = [],
-          unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
-
-    metaConsequentVerified = unqualifiedStatementVerified; ///
-  }
-
-  if (unqualifiedMetastatementNode !== null) {
-    const derived = false,
-          assignments = [],
-          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
-
-    metaConsequentVerified = unqualifiedMetastatementVerified; ///
-  }
-
-  if (metaConsequentVerified) {
-    let metaConsequent;
-
-    if (unqualifiedStatementNode !== null) {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode);
-
-      metaConsequent = MetaConsequent.fromStatementNode(statementNode);
-    }
-
-    if (unqualifiedMetastatementNode !== null) {
-      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
-
-      metaConsequent = MetaConsequent.fromMetastatementNode(metastatementNode);
-    }
-
-    metaConsequents.push(metaConsequent);
-
-    localContext.debug(`...verified the '${metaConsequentString}' meta-consequent.`, metaConsequentNode);
-  }
-
-  return metaConsequentVerified;
-}

package/src/verify/metaDerivation.js

@@ -1,23 +0,0 @@
-"use strict";
-
-import verifyMetaproofStep from "../verify/metaproofStep";
-
-import { nodesQuery } from "../utilities/query";
-
-const metaproofStepNodesQuery = nodesQuery("/metaDerivation/metaproofStep|lastMetaproofStep");
-
-export default function verifyMetaDerivation(metaDerivationNode, substitutions, localContext) {
-  let metaDerivationVerified;
-
-  const metaproofStepNodes = metaproofStepNodesQuery(metaDerivationNode);
-
-  metaDerivationVerified = metaproofStepNodes.every((metaproofStepNode) => {
-    const metaproofStepVerified = verifyMetaproofStep(metaproofStepNode, substitutions, localContext);
-
-    if (metaproofStepVerified) {
-      return true;
-    }
-  });
-
-  return metaDerivationVerified;
-}

package/src/verify/metaSubDerivation.js

@@ -1,22 +0,0 @@
-"use strict";
-
-import { nodesQuery } from "../utilities/query";
-
-const metaproofStepNodesQuery = nodesQuery("/metaSubDerivation/metaproofStep|lastMetaproofStep");
-
-export default function verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localContext) {
-  let metaSubDerivationVerified;
-
-  const metaproofStepNodes = metaproofStepNodesQuery(metaSubDerivationNode);
-
-  metaSubDerivationVerified = metaproofStepNodes.every((metaproofStepNode) => {
-    const { verifyMetaproofStep } = verifyMetaSubDerivation,
-          metaproofStepVerified = verifyMetaproofStep(metaproofStepNode, substitutions, localContext);
-
-    if (metaproofStepVerified) {
-      return true;
-    }
-  });
-
-  return metaSubDerivationVerified;
-}

package/src/verify/metaSubproof.js

@@ -1,32 +0,0 @@
-"use strict";
-
-import LocalContext from "../context/local";
-import verifyMetaSuppositions from "../verify/metaSuppositions";
-import verifyMetaSubDerivation from "../verify/metaSubDerivation";
-
-import { nodeQuery, nodesQuery } from "../utilities/query";
-
-const metaSuppositionNodesQuery = nodesQuery("/metaSubproof/metaSupposition"),
-      metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
-
-export default function verifyMetaSubproof(metaSubproofNode, substitutions, localContext) {
-  let metaSubproofVerified = false;
-
-  localContext = LocalContext.fromLocalContext(localContext); ///
-
-  const metaSuppositions = [],
-        metaSuppositionNodes = metaSuppositionNodesQuery(metaSubproofNode),
-        metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localContext);
-
-  if (metaSuppositionsVerified) {
-    const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
-          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, substitutions, localContext);
-
-    if (metaSubDerivationVerified) {
-      metaSubproofVerified = true;
-    }
-  }
-
-  return metaSubproofVerified;
-}
-

package/src/verify/metaSupposition.js

@@ -1,78 +0,0 @@
-"use strict";
-
-import MetaproofStep from "../step/metaproof";
-import MetaSupposition from "../metaSupposition";
-import verifyUnqualifiedStatement from "./statement/unqualified";
-import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
-
-import { nodeQuery } from "../utilities/query";
-import { assignAssignment } from "../utilities/assignments";
-
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
-      unqualifiedStatementNodeQuery = nodeQuery("/metaSupposition/unqualifiedStatement!"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/metaSupposition/unqualifiedMetastatement!");
-
-export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localContext) {
-  let metaSuppositionVerified = false;
-
-  const metaSuppositionString = localContext.nodeAsString(metaSuppositionNode);
-
-  localContext.trace(`Verifying the '${metaSuppositionString}' meta-supposition...`, metaSuppositionNode);
-
-  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(metaSuppositionNode),
-        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSuppositionNode);
-
-  if (unqualifiedStatementNode !== null) {
-    const derived = false,
-          assignments = [],
-          unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
-
-    if (unqualifiedStatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      metaSuppositionVerified = assignmentAssigned; ///
-    }
-  }
-
-  if (unqualifiedMetastatementNode !== null) {
-    const derived = false,
-          assignments = [],
-          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
-
-    if (unqualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      metaSuppositionVerified = assignmentAssigned; ///
-    }
-  }
-
-  if (metaSuppositionVerified) {
-    let metaSupposition,
-        metaproofStep;
-
-    if (unqualifiedStatementNode !== null) {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode);
-
-      metaSupposition = MetaSupposition.fromStatementNode(statementNode);
-
-      metaproofStep = MetaproofStep.fromMetastatementNode(statementNode);
-    }
-
-    if (unqualifiedMetastatementNode !== null) {
-      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
-
-      metaSupposition = MetaSupposition.fromMetastatementNode(metastatementNode);
-
-      metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-    }
-
-    metaSuppositions.push(metaSupposition);
-
-    localContext.addMetaproofStep(metaproofStep);
-
-    localContext.debug(`...verified the '${metaSuppositionString}' meta-supposition.`, metaSuppositionNode);
-  }
-
-  return metaSuppositionVerified;
-}

package/src/verify/metaSuppositions.js

@@ -1,17 +0,0 @@
-"use strict";
-
-import verifyMetaSupposition from "../verify/metaSupposition";
-
-export default function verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, substitutions, localContext) {
-  let metaSuppositionsVerified;
-
-  metaSuppositionsVerified = metaSuppositionNodes.every((metaSuppositionNode) => {
-    const metaSuppositionVerified = verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localContext);
-
-    if (metaSuppositionVerified) {
-      return true;
-    }
-  });
-
-  return metaSuppositionsVerified;
-}

package/src/verify/metaproof.js

@@ -1,28 +0,0 @@
-"use strict";
-
-import LocalContext from "../context/local";
-import verifyMetaDerivation from "../verify/metaDerivation";
-
-import { nodeQuery } from "../utilities/query";
-
-const metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!");
-
-export default function verifyMetaproof(metaproofNode, metastatementNode, substitutions, localContext) {
-  let metaproofVerified = false;
-
-  localContext = LocalContext.fromLocalContext(localContext); ///
-
-  const metaDerivationNode = metaDerivationNodeQuery(metaproofNode),
-        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, substitutions, localContext);
-
-  if (metaDerivationVerified) {
-    const lastMetaproofStep = localContext.getLastMetaproofStep(),
-          lastMetaproofStepMetastatementNode = lastMetaproofStep.getMetastatementNode(),
-          lastMetastatementNode = lastMetaproofStepMetastatementNode, ///
-          lastMetastatementNodeMatchesMetastatementNode = lastMetastatementNode.match(metastatementNode);
-
-    metaproofVerified = lastMetastatementNodeMatchesMetastatementNode;  ///
-  }
-
-  return metaproofVerified;
-}