occam-verify-cli 0.0.921 → 0.0.923

package/src/context/local/metaLevel.js

@@ -1,191 +0,0 @@
-"use strict";
-
-import IntrinsicLevelLocalContext from "../../context/local/intrinsicLevel";
-
-import { last, reverse } from "../../utilities/array";
-
-class MetaLevelLocalContext extends IntrinsicLevelLocalContext {
-  constructor(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps) {
-    super(context, variables, proofSteps, equivalences);
-
-    this.judgements = judgements;
-    this.metavariables = metavariables;
-    this.metaproofSteps = metaproofSteps;
-  }
-
-  getJudgements() {
-    let judgements = this.context.getJudgements();
-
-    judgements = [ ///
-      ...this.judgements,
-      ...judgements
-    ]
-
-    return judgements;
-  }
-
-  getMetavariables() {
-    let metavariables = this.context.getMetavariables();
-
-    metavariables = [ ///
-      ...this.metavariables,
-      ...metavariables
-    ]
-
-    return metavariables;
-  }
-
-  getMetaproofSteps() {
-    let metaproofSteps = this.context.getMetaproofSteps();
-
-    metaproofSteps = [  ///
-      ...metaproofSteps,
-      ...this.metaproofSteps
-    ];
-
-    return metaproofSteps;
-  }
-
-  isIntrinsicLevel() {
-    const intrinsicLevel = false;
-
-    return intrinsicLevel;
-  }
-
-  getLastMetaproofStep() {
-    let lastMetaproofStep = null;
-
-    const metaproofStepsLength = this.metaproofSteps.length;
-
-    if (metaproofStepsLength > 0) {
-      lastMetaproofStep = last(this.metaproofSteps);
-    }
-
-    return lastMetaproofStep;
-  }
-
-  addJudgement(judgement) {
-    let judgementAdded = false;
-
-    const metavariableNode = judgement.getMetavariableNode(),
-          judgementPresent = this.isJudgementPresentByMetavariableNode(metavariableNode);
-
-    if (!judgementPresent) {
-      this.judgements.push(judgement);
-
-      judgementAdded = true;
-    }
-
-    return judgementAdded;
-  }
-
-  addMetavariable(metavariable) {
-    let metavariableAdded = false;
-
-    const node = metavariable.getName(),
-          metavariablePresent = this.metavariables.some((metavariable) => {
-            const metavariableMatchesNode = metavariable.matchNode(node);
-
-            if (metavariableMatchesNode) {
-              return true;
-            }
-          });
-
-    if (!metavariablePresent) {
-      this.metavariables.push(metavariable);
-
-      metavariableAdded = true;
-    }
-
-    return metavariableAdded;
-  }
-
-  addMetaproofStep(metaproofStep) {
-    this.metaproofSteps.push(metaproofStep);
-  }
-
-  matchMetastatementNode(metastatementNode) {
-    let metaproofSteps = this.getMetaproofSteps();
-
-    metaproofSteps = reverse(metaproofSteps); ///
-
-    const matchesMetastatementNode = metaproofSteps.some((metaproofStep) => {
-      const metaproofStepMatchesMetastatementNode = metaproofStep.matchMetastatementNode(metastatementNode);
-
-      if (metaproofStepMatchesMetastatementNode) {
-        return true;
-      }
-    });
-
-    return matchesMetastatementNode;
-  }
-
-  findMetavariableByMetavariableNode(metavariableNode, metaLevelLocalContext) {
-    const node = metavariableNode,  ///
-          metavariables = this.getMetavariables(),
-          metavariable = metavariables.find((metavariable) => {
-            const matches = metavariable.matchNode(node, metaLevelLocalContext);
-
-            if (matches) {
-              return true;
-            }
-          }) || null;
-
-    return metavariable;
-  }
-
-  findJudgementByMetavariableNode(metavariableNode) {
-    const judgements = this.getJudgements(),
-          judgement = judgements.find((judgement) => {
-            const judgementMatchesMetavariableNode = judgement.matchMetavariableNode(metavariableNode);
-
-            if (judgementMatchesMetavariableNode) {
-              return true;
-            }
-          }) || null;
-
-    return judgement;
-  }
-
-  isMetavariablePresentByMetavariableNode(metavariableNode, metaLevelLocalContext) {
-    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, metaLevelLocalContext),
-          metavariablePresent = (metavariable !== null);
-
-    return metavariablePresent;
-  }
-
-  isJudgementPresentByMetavariableNode(metavariableNode) {
-    const judgement = this.findJudgementByMetavariableNode(metavariableNode),
-          judgementPresent = (judgement !== null);
-
-    return judgementPresent;
-  }
-
-  static fromFileContext(fileContext) {
-    const context = fileContext,  ///
-          variables = [],
-          proofSteps = [],
-          equivalences = [],
-          judgements = [],
-          metavariables = [],
-          metaproofSteps = [],
-          metaLevelLocalContext = new MetaLevelLocalContext(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps);
-
-    return metaLevelLocalContext;
-  }
-
-  static fromLocalContext(localContext) {
-    const context = localContext,  ///
-          variables = [],
-          proofSteps = [],
-          equivalences = [],
-          judgements = [],
-          metavariables = [],
-          metaproofSteps = [],
-          metaLevelLocalContext = new MetaLevelLocalContext(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps);  ///
-
-    return metaLevelLocalContext;
-  }
-}
-
-export default MetaLevelLocalContext;

package/src/metaConsequent.js

@@ -1,83 +0,0 @@
-"use strict";
-
-import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
-import MetaLevelLocalContext from "./context/local/metaLevel";
-
-import { nodeAsString } from "./utilities/string";
-import { statementNodeFromStatementString, metastatementNodeFromMetastatementString } from "./utilities/node";
-
-export default class MetaConsequent {
-  constructor(metastatementNode, statementNode) {
-    this.metastatementNode = metastatementNode;
-    this.statementNode = statementNode;
-  }
-
-  getMetastatementNode() {
-    return this.metastatementNode;
-  }
-
-  getStatementNode() {
-    return this.statementNode;
-  }
-
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext) {
-    let matchesMetastatementNode = false;
-
-    if (this.metastatementNode !== null) {
-      const metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
-            nonTerminalNodeA = this.metastatementNode,  ///
-            nonTerminalNodeB = metastatementNode,  ///
-            localContextA = metaLevelLocalContext,  ///
-            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,
-          metaConsequent = new MetaConsequent(metastatementNode, statementNode);
-
-    return metaConsequent;
-  }
-
-  static fromMetastatementNode(metastatementNode) {
-    const statementNode = null,
-          metaConsequent = new MetaConsequent(metastatementNode, statementNode);
-
-    return metaConsequent;
-  }
-
-  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),
-          metaConsequent = new MetaConsequent(metastatementNode, statementNode);
-
-    return metaConsequent;
-  }
-}

package/src/metaSupposition.js

@@ -1,127 +0,0 @@
-"use strict";
-
-import MetaLevelLocalContext from "./context/local/metaLevel";
-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 metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
-                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                localContextA = metaLevelLocalContext,  ///
-                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 metaLevelLocalContext = MetaLevelLocalContext.fromFileContext(fileContext),
-            nonTerminalNodeA = this.metastatementNode,  ///
-            nonTerminalNodeB = metastatementNode,  ///
-            localContextA = metaLevelLocalContext,  ///
-            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;
-}