occam-verify-cli 1.0.983 → 1.0.985

package/src/element/signature.js

@@ -1,292 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-import { arrayUtilities } from "necessary";
-
-import { define } from "../elements";
-import { instantiateSignature } from "../process/instantiate";
-import { signatureFromSignatureNode } from "../utilities/element";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { ablate, attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
-
-const { match } = arrayUtilities;
-
-export default define(class Signature extends Element {
-  constructor(context, string, node, breakPoint, terms) {
-    super(context, string, node, breakPoint);
-
-    this.terms = terms;
-  }
-
-  getTerms() {
-    return this.terms;
-  }
-
-  getSignatureNode() {
-    const node = this.getNode(),
-          signatureNode = node; ///
-
-    return signatureNode;
-  }
-
-  getLength() {
-    const termsLength = this.terms.length,
-          length = termsLength; ///
-
-    return length;
-  }
-
-  getTerm(index) {
-    const term = this.terms[index];
-
-    return term;
-  }
-
-  isEqualTo(signature) {
-    const signatureNode = signature.getNode(),
-          signatureNodeMatches = this.matchSignatureNode(signatureNode),
-          equalTo = signatureNodeMatches;  ///
-
-    return equalTo;
-  }
-
-  matchSignatureNode(signatureNode) {
-    const node = signatureNode, ///
-          nodeMatches = this.matchNode(node),
-          signatureNodeMatches = nodeMatches; ///
-
-    return signatureNodeMatches;
-  }
-
-  findValidSignature(context) {
-    const signatureNode = this.getSignatureNode(),
-          signature = context.findSignatureBySignatureNode(signatureNode),
-          validSignature = signature;  ///
-
-    return validSignature;
-  }
-
-  verify(context) {
-    let verifies = false;
-
-    const signatureString = this.getString();  ///
-
-    context.trace(`Verifying the '${signatureString}' signature...`);
-
-    ablate((context) => {
-      attempt((context) => {
-        const termsValidate = this.validateTerms(context);
-
-        if (termsValidate !== null) {
-          verifies = true;
-        }
-
-        if (verifies) {
-          this.commit(context);
-        }
-      }, context);
-    }, context);
-
-    if (verifies) {
-      context.debug(`...validated the '${signatureString}' signature.`);
-    }
-
-    return verifies;
-  }
-
-  validate(context) {
-    let signature = null;
-
-    const signatureString = this.getString();  ///
-
-    context.trace(`Validating the '${signatureString}' signature...`);
-
-    let validates = false;
-
-    const validSignature = this.findValidSignature(context);
-
-    if (validSignature) {
-      validates = true;
-
-      signature = validSignature;  ///
-
-      context.debug(`...the '${signatureString}' signature is already valid.`);
-    } else {
-      const temporaryContext = context; ///
-
-      context = this.getContext();
-
-      attempt((context) => {
-        const termsValidate = this.validateTerms(context);
-
-        if (termsValidate !== null) {
-          validates = true;
-        }
-
-        if (validates) {
-          this.commit(context);
-        }
-      }, context);
-
-      context = temporaryContext; ///
-
-      if (validates) {
-        signature = this; ///
-
-        context.addSignature(signature);
-      }
-    }
-
-    if (validates) {
-      context.debug(`...validated the '${signatureString}' signature.`);
-    }
-
-    return signature;
-  }
-
-  validateTerms(context) {
-    let termsValidate;
-
-    const signatureString = this.getString();  ///
-
-    context.trace(`Validating the '${signatureString}' signature's terms...`);
-
-    const terms = [];
-
-    termsValidate = this.terms.every((term) => {
-      term = term.validate(context, (term, context) => { ///
-        const validatesForwards = true;
-
-        return validatesForwards;
-      });
-
-      if (term !== null) {
-        terms.push(term);
-
-        return true;
-      }
-    });
-
-    if (termsValidate) {
-      this.terms = terms;
-    }
-
-    if (termsValidate){
-      context.debug(`...validated the '${signatureString}' signature's terms.`);
-    }
-
-    return termsValidate
-  }
-
-  unifySignature(signature, context) {
-    let signatureUnifies;
-
-    const generalSignature = this,
-          specificSignature = signature,  ///
-          generalSignatureString = generalSignature.getString(),
-          specificSignatureString = specificSignature.getString();
-
-    context.trace(`Unifying the '${specificSignatureString}' signature with the '${generalSignatureString}' signature...`);
-
-    const generalSignatureTerms = generalSignature.getTerms(),
-          specificSignatureTerms = specificSignature.getTerms(),
-          generalSignatureContext = generalSignature.getContext(),
-          specificSignatureContext = specificSignature.getContext(),
-          generalTerms = generalSignatureTerms,  ///
-          specificTerms = specificSignatureTerms, ///
-          generalContext = generalSignatureContext, ///
-          specificContext = specificSignatureContext;  ///
-
-    reconcile((specificContext) => {
-      signatureUnifies = match(generalTerms, specificTerms, (generalTerm, specificTerm) => {
-        let termUnifies;
-
-        termUnifies = generalTerm.unifyTerm(specificTerm, generalContext, specificContext);
-
-        if (termUnifies) {
-          return true;
-        }
-      });
-
-      if (signatureUnifies) {
-        specificContext.commit(context);
-      }
-    }, specificContext);
-
-    if (signatureUnifies) {
-      context.debug(`...unified the '${specificSignatureString}' signature with the '${generalSignatureString}' signature.`);
-    }
-
-    return signatureUnifies;
-  }
-
-  static name = "Signature";
-
-  toJSON() {
-    const context = this.getContext();
-
-    return serialise((context) => {
-      const string = this.getString();
-
-      let breakPoint;
-
-      breakPoint = this.getBreakPoint();
-
-      const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-      breakPoint = breakPointJSON;  ///
-
-      const json = {
-        context,
-        string,
-        breakPoint
-      };
-
-      return json;
-    }, context);
-  }
-
-  static fromJSON(json, context) {
-    let signature;
-
-    instantiate((context) => {
-      unserialise((json, context) => {
-        const { string } = json,
-              signatureNode = instantiateSignature(string, context),
-              node = signatureNode,  ///
-              breakPoint = breakPointFromJSON(json),
-              terms = termsFromSignatureNode(signatureNode, context);
-
-        signature = new Signature(context, string, node, breakPoint, terms);
-      }, json, context);
-    }, context);
-
-    return signature;
-  }
-
-  static fromSignatureString(signatureString, context) {
-    let signature;
-
-    ablate((context) => {
-      instantiate((context) => {
-        const string = signatureString,  ///
-              signatureNode = instantiateSignature(string, context);
-
-        signature = signatureFromSignatureNode(signatureNode, context);
-      }, context);
-    }, context);
-
-    return signature;
-  }
-});
-
-function termsFromSignatureNode(signatureNode, context) {
-  const termNodes = signatureNode.getTermNodes(),
-        terms = termNodes.map((termNode) => {
-          const term = context.findTermByTermNode(termNode);
-
-          return term;
-        });
-
-  return terms;
-}

package/src/element/statement.js

@@ -1,358 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-import { define } from "../elements";
-import { instantiate } from "../utilities/context";
-import { unifyStatement } from "../process/unify";
-import { validateStatements } from "../process/validation";
-import { dischargeStatements } from "../process/discharge";
-import { instantiateStatement } from "../process/instantiate";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-
-export default define(class Statement extends Element {
-  getStatementNode() {
-    const node = this.getNode(),
-          statementNode = node; ///
-
-    return statementNode;
-  }
-
-  getTermSubstitutionNode() {
-    const statementNode = this.getNode(),
-          termSubstitutionNode = statementNode.getTermSubstitutionNode();
-
-    return termSubstitutionNode;
-  }
-
-  getFrameSubstitutionNode() {
-    const statementNode = this.getNode(),
-          frameSubstitutionNode = statementNode.getFrameSubstitutionNode();
-
-    return frameSubstitutionNode;
-  }
-
-  getMetavariableNode() {
-    let metavariableNode = null;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const statementNode = this.getStatementNode();
-
-      metavariableNode = statementNode.getMetavariableNode();
-    }
-
-    return metavariableNode;
-  }
-
-  getMetavariableName() {
-    let metavariableName = null;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const statementNode = this.getStatementNode(),
-            metavariableNode = statementNode.getMetavariableNode();
-
-      metavariableName = metavariableNode.getMetavariableName();
-    }
-
-    return metavariableName;
-  }
-
-  isEqualTo(statement) {
-    const statementNode = statement.getNode(),
-          statementNodeMatches = this.matchStatementNode(statementNode),
-          equalTo = statementNodeMatches;  ///
-
-    return equalTo;
-  }
-
-  isSingular() {
-    const statementNode = this.getStatementNode(),
-          singular = statementNode.isSingular();
-
-    return singular;
-  }
-
-  matchStatementNode(statementNode) {
-    const node = statementNode, ///
-          nodeMatches = this.matchNode(node),
-          statementNodeMatches = nodeMatches; ///
-
-    return statementNodeMatches;
-  }
-
-  matchMetavariableNode(metavariableNode) {
-    let metavariableNodeMatches = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const metavariableNodeA = metavariableNode, ///
-            statementNode = this.getStatementNode();
-
-      metavariableNode = statementNode.getMetavariableNode();
-
-      const metavariableNodeB = metavariableNode, ///
-            metavariableNodeAMatchesMetavariableNodeB = metavariableNodeA.match(metavariableNodeB);
-
-      if (metavariableNodeAMatchesMetavariableNodeB) {
-        metavariableNodeMatches = true;
-      }
-    }
-
-    return metavariableNodeMatches;
-  }
-
-  compareParameter(parameter) {
-    let comparesToParamter = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const parameterName = parameter.getName();
-
-      if (parameterName !== null) {
-        const metavariableName = this.getMetavariableName();
-
-        if (parameterName === metavariableName) {
-          comparesToParamter = true;
-        }
-      }
-    }
-
-    return comparesToParamter;
-  }
-
-  findValidStatement(context) {
-    const statementNode = this.getStatementNode(),
-          statement = context.findStatementByStatementNode(statementNode),
-          validStatement = statement;  ///
-
-    return validStatement;
-  }
-
-  isTermContained(term, context) {
-    let termContained;
-
-    const termString = term.getString(),
-          statementString = this.getString();  ///
-
-    context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`);
-
-    const statementNode = this.getStatementNode(),
-          statementNodeTermNodes = statementNode.getTermNodes();
-
-    termContained = statementNodeTermNodes.some((statementNodeTermNode) => {  ///
-      const statementNodeTermNodeMatches = term.matchTermNode(statementNodeTermNode);
-
-      if (statementNodeTermNodeMatches) {
-        return true;
-      }
-    });
-
-    if (termContained) {
-      context.debug(`...the '${termString}' term is contained in the '${statementString}' statement.`);
-    }
-
-    return termContained;
-  }
-
-  isFrameContained(frame, context) {
-    let frameContained;
-
-    const frameString = frame.getString(),
-          statementString = this.getString();  ///
-
-    context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`);
-
-    const statementNode = this.getStatementNode(),
-          statementNodeFrameNodes = statementNode.getFrameNodes();
-
-    frameContained = statementNodeFrameNodes.some((statementNodeFrameNode) => {  ///
-      const statementNodeFrameNodeMatches = frame.matchNode(statementNodeFrameNode);
-
-      if (statementNodeFrameNodeMatches) {
-        return true;
-      }
-    });
-
-    if (frameContained) {
-      context.debug(`...the '${frameString}' frame is contained in the '${statementString}' statement.`);
-    }
-
-    return frameContained;
-  }
-
-  validate(context) {
-    let statement = null;
-
-    const statementString = this.getString();  ///
-
-    context.trace(`Validating the '${statementString}' statement...`);
-
-    let validates;
-
-    const validStatement = this.findValidStatement(context);
-
-    if (validStatement !== null) {
-      validates = true;
-
-      statement = validStatement; ///
-
-      context.debug(`...the '${statementString}' statement is already valid.`);
-    } else {
-      validates = validateStatements.some((validateStatement) => {
-        const statement = this, ///
-              statementValidates = validateStatement(statement, context);
-
-        if (statementValidates) {
-          return true;
-        }
-      });
-
-      if (validates) {
-        statement = this; ///
-
-        context.addStatement(statement);
-      }
-    }
-
-    if (validates) {
-      context.debug(`...validated the '${statementString}' statement.`);
-    }
-
-    return statement;
-  }
-
-  discharge(context) {
-    let discharges;
-
-    const statementString = this.getString();  ///
-
-    context.trace(`Dicharging the '${statementString}' statement...`);
-
-    discharges = dischargeStatements.some((dischargeStatement) => {
-      const statement = this, ///
-            statementDischarged = dischargeStatement(statement, context);
-
-      if (statementDischarged) {
-        return true;
-      }
-    });
-
-    if (discharges) {
-      context.debug(`...discharged the '${statementString}' statement.`);
-    }
-
-    return discharges;
-  }
-
-  unifyStatement(statement, generalContext, specificContext) {
-    let statementUnifies;
-
-    const context = specificContext,  ///
-          generalStatement = this,  ///
-          specificStatement = statement, ///
-          generalStatementString = generalStatement.getString(),
-          specificStatementString = specificStatement.getString();
-
-    context.trace(`Unifying the '${specificStatementString}' statement with the '${generalStatementString}' statement...`);
-
-    statementUnifies = unifyStatement(generalStatement, specificStatement, generalContext, specificContext);
-
-    if (statementUnifies) {
-      context.debug(`...unified the '${specificStatementString}' statement with the '${generalStatementString}' statement.`);
-    }
-
-    return statementUnifies;
-  }
-
-  unifyIndependently(generalContext, specificContext) {
-    let unifiesIndependently = false;
-
-    const context = specificContext,  ///
-          statementString = this.getString();  ///
-
-    context.trace(`Unifying the '${statementString}' statement independently...`);
-
-    const statementNode = this.getStatementNode(),
-          typeAssertionNode = statementNode.getTypeAssertionNode(),
-          definedAssertionNode = statementNode.getDefinedAssertionNode(),
-          containedAssertionNode = statementNode.getContainedAssertionNode();
-
-    if (typeAssertionNode !== null) {
-      const context = generalContext, ///
-            typeAssertion = context.findAssertionByAssertionNode(typeAssertionNode),
-            typeAssertionUnifiesIndependently = typeAssertion.unifyIndependently(generalContext, specificContext);
-
-      if (typeAssertionUnifiesIndependently) {
-        unifiesIndependently = true;
-      }
-    }
-
-    if (definedAssertionNode !== null) {
-      const context = generalContext, ///
-            definedAssertion = context.findAssertionByAssertionNode(definedAssertionNode),
-            definedAssertionUnifiesIndependently = definedAssertion.unifyIndependently(generalContext, specificContext);
-
-      if (definedAssertionUnifiesIndependently) {
-        unifiesIndependently = true;
-      }
-    }
-
-    if (containedAssertionNode !== null) {
-      const context = generalContext, ///
-            containedAssertion = context.findAssertionByAssertionNode(containedAssertionNode),
-            containedAssertionUnifiesIndependently = containedAssertion.unifyIndependently(generalContext, specificContext);
-
-      if (containedAssertionUnifiesIndependently) {
-        unifiesIndependently = true;
-      }
-    }
-
-    if (unifiesIndependently) {
-      context.debug(`...unified the '${statementString}' statement independently.`);
-    }
-
-    return unifiesIndependently;
-  }
-
-  static name = "Statement";
-
-  toJSON() {
-    const string = this.getString();
-
-    let breakPoint;
-
-    breakPoint = this.getBreakPoint();
-
-    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-    breakPoint = breakPointJSON;  ///
-
-    const json = {
-      string,
-      breakPoint
-    };
-
-    return json;
-  }
-
-  static fromJSON(json, context) {
-    return instantiate((context) => {
-      const { string } = json,
-            statementNode = instantiateStatement(string, context),
-            node = statementNode, ///
-            breakPoint = breakPointFromJSON(json);
-
-      context = null;
-
-      const statement = new Statement(context, string, node, breakPoint);
-
-      return statement;
-    }, context);
-  }
-});

package/src/element/subDerivation.js

@@ -1,56 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-import { Element, asynchronousUtilities } from "occam-languages";
-
-import { define } from "../elements";
-
-const { last } = arrayUtilities,
-      { asyncEvery } = asynchronousUtilities;
-
-export default define(class SubDerivation extends Element {
-  constructor(context, string, node, breakPoint, subproofOrProofAssertions) {
-    super(context, string, node, breakPoint);
-
-    this.subproofOrProofAssertions = subproofOrProofAssertions;
-  }
-
-  getSubproofOrProofAssertions() {
-    return this.subproofOrProofAssertions;
-  }
-
-  getSubDerivationNode() {
-    const node = this.getNode(),
-          subDerivationNode = node; ///
-
-    return subDerivationNode;
-  }
-
-  getLastStep() {
-    const lastSubproofOrProofAssertion = last(this.subproofOrProofAssertions),
-          lastProofAssertion = lastSubproofOrProofAssertion,  ///
-          lastStep = lastProofAssertion;  ///
-
-    return lastStep;
-  }
-
-  async verify(context) {
-    let verifies;
-
-    verifies = await asyncEvery(this.subproofOrProofAssertions, async (subproofOrProofAssertion) => { ///
-      const subproofOrProofAssertionVarifies = await subproofOrProofAssertion.verify(context);
-
-      if (subproofOrProofAssertionVarifies) {
-        context.assignAssignments();
-
-        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
-
-        return true;
-      }
-    });
-
-    return verifies;
-  }
-
-  static name = "SubDerivation";
-});