occam-verify-cli 0.0.920 → 0.0.922

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/verify/ruleDerivation.js

@@ -1,23 +0,0 @@
-"use strict";
-
-import verifyRuleProofStep from "../verify/ruleProofStep";
-
-import { nodesQuery } from "../utilities/query";
-
-const ruleProofStepNodesQuery = nodesQuery("/ruleDerivation/ruleProofStep|lastRuleProofStep");
-
-export default function verifyRuleDerivation(ruleDerivationNode, localContext) {
-  let ruleDerivationVerified;
-
-  const ruleProofStepNodes = ruleProofStepNodesQuery(ruleDerivationNode);
-
-  ruleDerivationVerified = ruleProofStepNodes.every((ruleProofStepNode) => {
-    const ruleProofStepVerified = verifyRuleProofStep(ruleProofStepNode, localContext);
-
-    if (ruleProofStepVerified) {
-      return true;
-    }
-  });
-
-  return ruleDerivationVerified;
-}

package/src/verify/ruleProof.js

@@ -1,31 +0,0 @@
-"use strict";
-
-import verifyRuleDerivation from "../verify/ruleDerivation";
-import MetaLevelLocalContext from "../context/local/metaLevel";
-
-import { nodeQuery } from "../utilities/query";
-
-const ruleDerivationNodeQuery = nodeQuery("/ruleProof/ruleDerivation!");
-
-export default function verifyRuleProof(ruleProofNode, conclusion, localContext) {
-  let ruleProofVerified = false;
-
-  const metaLevelLocalContext = MetaLevelLocalContext.fromLocalContext(localContext);
-
-  localContext = metaLevelLocalContext; ///
-
-  const ruleDerivationNode = ruleDerivationNodeQuery(ruleProofNode),
-        ruleDerivationVerified = verifyRuleDerivation(ruleDerivationNode, localContext);
-
-  if (ruleDerivationVerified) {
-    const lastMetaproofStep = localContext.getLastMetaproofStep(),
-          metaproofStep = lastMetaproofStep, ///
-          metastatementNode = metaproofStep.getMetastatementNode(),
-          conclusionMetastatementNode = conclusion.getMetastatementNode(),
-          metastatementNodeMatchConclusionMetastatementNode = metastatementNode.match(conclusionMetastatementNode);
-
-    ruleProofVerified = metastatementNodeMatchConclusionMetastatementNode;  ///
-  }
-
-  return ruleProofVerified;
-}

package/src/verify/ruleProofStep.js

@@ -1,139 +0,0 @@
-"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 statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
-      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, localContext) {
-  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, localContext);
-
-    if (ruleSubproofVerified) {
-      const metaproofStep = MetaproofStep.fromRuleSubproofNode(ruleSubproofNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      ruleProofStepVerified = 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),
-            metaproofStep = MetaproofStep.fromStatementNode(statementNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      ruleProofStepVerified = 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),
-            metaproofStep = MetaproofStep.fromStatementNode(statementNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      ruleProofStepVerified = unqualifiedStatementVerified; ///
-    }
-  } else if (qualifiedMetastatementNode !== null) {
-    let qualifiedMetastatementVerified;
-
-    const assignments = [],
-          substitutions = null;
-
-    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localContext);
-
-    if (qualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      qualifiedMetastatementVerified = assignmentAssigned; ///
-    }
-
-    if (qualifiedMetastatementVerified) {
-      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      ruleProofStepVerified = qualifiedMetastatementVerified; ///
-    }
-  } else if (unqualifiedMetastatementNode !== null) {
-    let unqualifiedMetastatementVerified;
-
-    const derived = true,
-          assignments = [];
-
-    unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
-
-    if (unqualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      unqualifiedMetastatementVerified = assignmentAssigned; ///
-    }
-
-    if (unqualifiedMetastatementVerified) {
-      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      ruleProofStepVerified = true;
-    }
-  }
-
-  return ruleProofStepVerified;
-}
-
-Object.assign(verifyRuleSubDerivation, {
-  verifyRuleProofStep
-});

package/src/verify/ruleSubDerivation.js

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

package/src/verify/ruleSubproof.js

@@ -1,34 +0,0 @@
-"use strict";
-
-import verifyPremises from "../verify/premises";
-import MetaLevelLocalContext from "../context/local/metaLevel";
-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, localContext) {
-  let ruleSubproofVerified = false;
-
-  const metaLevelLocalContext = MetaLevelLocalContext.fromLocalContext(localContext);
-
-  localContext = metaLevelLocalContext; ///
-
-  const premises = [],
-        premiseNodes = premiseNodesQuery(ruleSubproofNode),
-        premisesVerified = verifyPremises(premiseNodes, premises, localContext);
-
-  if (premisesVerified) {
-    const ruleSubDerivationNode = ruleSubDerivationNodeQuery(ruleSubproofNode),
-          ruleSubDerivationVerified = verifyRuleSubDerivation(ruleSubDerivationNode, localContext);
-
-    if (ruleSubDerivationVerified) {
-      ruleSubproofVerified = true;
-    }
-  }
-
-  return ruleSubproofVerified;
-}
-