occam-verify-cli 1.0.983 → 1.0.985

package/src/element/term.js

@@ -1,339 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-import { arrayUtilities } from "necessary";
-
-import { define } from "../elements";
-import { instantiate } from "../utilities/context";
-import { validateTerms } from "../process/validation";
-import { instantiateTerm } from "../process/instantiate";
-import { variablesFromTerm } from "../utilities/equivalence";
-import { unifyTermIntrinsically } from "../process/unify";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { typeFromJSON, typeToTypeJSON, provisionalFromJSON, provisionalToProvisionalJSON } from "../utilities/json";
-
-const { filter } = arrayUtilities;
-
-export default define(class Term extends Element {
-  constructor(context, string, node, breakPoint, type, provisional) {
-    super(context, string, node, breakPoint, provisional);
-
-    this.type = type;
-    this.provisional = provisional;
-  }
-
-  getType() {
-    return this.type;
-  }
-
-  isProvisional() {
-    return this.provisional;
-  }
-
-  setType(type) {
-    this.type = type;
-  }
-
-  setProvisional(provisional) {
-    this.provisional = provisional;
-  }
-
-  getTermNode() {
-    const node = this.getNode(),
-          termNode = node;  ///
-
-    return termNode;
-  }
-
-  getVariableNode() {
-    const termNode = this.getTermNode(),
-          variableNode = termNode.getVariableNode();
-
-    return variableNode;
-  }
-
-  getVariableIdentifier() {
-    const termNode = this.getTermNode(),
-          variableIdentifier = termNode.getVariableIdentifier();
-
-    return variableIdentifier;
-  }
-
-  isEstablished() {
-    const provisional = this.isProvisional(),
-          established = !provisional;
-
-    return established;
-  }
-
-  isEqualTo(term) {
-    const termNode = term.getNode(),
-          termNodeMatches = this.matchTermNode(termNode),
-          equalTo = termNodeMatches;  ///
-
-    return equalTo;
-  }
-
-  isGrounded(definedVariables, context) {
-    const term  = this, ///
-          variables = variablesFromTerm(term, context);
-
-    filter(variables, (variable) => {
-      const definedVariablesIncludesVariable = definedVariables.includes(variable);
-
-      if (!definedVariablesIncludesVariable) {
-        return true;
-      }
-    });
-
-    const undefinedVariables = variables, ///
-          undefinedVariablesLength = undefinedVariables.length,
-          grounded = (undefinedVariablesLength <= 1);
-
-    return grounded;
-  }
-
-  isSingular() {
-    const termNode = this.getTermNode(),
-          singular = termNode.isSingular();
-
-    return singular;
-  }
-
-  isInitiallyGrounded(context) {
-    const term  = this, ///
-          variables = variablesFromTerm(term, context),
-          variablesLength = variables.length,
-          initiallyGrounded = (variablesLength === 0);
-
-    return initiallyGrounded;
-  }
-
-  isImplicitlyGrounded(definedVariables, context) {
-    const grounded = this.isGrounded(definedVariables, context),
-          implicitlyGrounded = grounded;  ///
-
-    return implicitlyGrounded;
-  }
-
-  matchTermNode(termNode) {
-    const node = termNode, ///
-          nodeMatches = this.matchNode(node),
-          termNodeMatches = nodeMatches; ///
-
-    return termNodeMatches;
-  }
-
-  matchVariableNode(variableNode) {
-    let variableNodeMatches = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const variableNodeA = variableNode; ///
-
-      variableNode = this.getVariableNode();
-
-      const variableNodeB = variableNode, ///
-            variableNodeAMatchesVariableNodeB = variableNodeA.match(variableNodeB);
-
-      if (variableNodeAMatchesVariableNodeB) {
-        variableNodeMatches = true; ///
-      }
-    }
-
-    return variableNodeMatches;
-  }
-
-  compareTerm(term) {
-    const termNode = term.getNode(),
-          termNodeMatches = this.matchNode(termNode),
-          comparesTo = termNodeMatches; ///
-
-    return comparesTo;
-  }
-
-  compareParameter(parameter) {
-    let comparesToParamter = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const parameterIdentifier = parameter.getIdentifier();
-
-      if (parameterIdentifier !== null) {
-        const variableIdentifier = this.getVariableIdentifier();
-
-        if (parameterIdentifier === variableIdentifier) {
-          comparesToParamter = true;
-        }
-      }
-    }
-
-    return comparesToParamter;
-  }
-
-  findValidTerm(context) {
-    const termNode = this.getTermNode(),
-          term = context.findTermByTermNode(termNode),
-          validTerm = term; ///
-
-    return validTerm;
-  }
-
-  validate(context, validateForwards) {
-    let term = null;
-
-    const termString = this.getString();  ///
-
-    context.trace(`Validating the '${termString}' term...`);
-
-    let validates = false;
-
-    const validTerm = this.findValidTerm(context);
-
-    if (validTerm !== null) {
-      term = validTerm; ///
-
-      const validatesForward = validateForwards(term, context);
-
-      if (validatesForward) {
-        validates = true;
-
-        context.debug(`...the '${termString}' term is already valid.`);
-      } else {
-        term = null;
-      }
-    } else {
-      validates = validateTerms.some((validateTerm) => {  ///
-        const term = this,  ///
-              termValidates = validateTerm(term, context, validateForwards);
-
-        if (termValidates) {
-          return true;
-        }
-      });
-
-      if (validates) {
-        term = this;  ///
-
-        context.addTerm(term);
-      }
-    }
-
-    if (validates) {
-      context.debug(`...validated the '${termString}' term.`);
-    }
-
-    return term;
-  }
-
-  validateGivenType(type, context) {
-    let term;
-
-    const typeString = type.getString(),
-          termString = this.getString();  ///
-
-    context.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
-
-    let validatesGivenType = false;
-
-    term = this.validate(context, (term, context) => {
-      let validatesForwards = false;
-
-      const termType = term.getType(),
-            termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
-
-      if (termTypeEqualToOrSubTypeOfType) {
-        validatesForwards = true;
-
-        const typeEstablished = type.isEstablished(),
-              termProvisional = term.isProvisional();
-
-        if (typeEstablished && termProvisional) {
-          validatesForwards = false;
-        }
-      }
-
-      return validatesForwards;
-    });
-
-    if (term !== null) {
-      validatesGivenType = true;
-    }
-
-    if (validatesGivenType) {
-      context.debug(`...validated the '${termString}' term given the '${typeString}' type.`);
-    }
-
-    return term;
-  }
-
-  unifyTerm(term, generalContext, specificContext) {
-    let termUnifies = false;
-
-    const context = specificContext,  ///
-          generalTerm = this,
-          specificTerm = term,
-          generalTermString = generalTerm.getString(),
-          specifixTermString = specificTerm.getString();
-
-    context.trace(`Unifying the '${specifixTermString}' term with the '${generalTermString}' term...`);
-
-    const termUnifiesIntrinsically = unifyTermIntrinsically(generalTerm, specificTerm, generalContext, specificContext);
-
-    if (termUnifiesIntrinsically) {
-      termUnifies = true;
-    }
-
-    if (termUnifies) {
-      context.debug(`...unified the '${specifixTermString}' term with the '${generalTermString}' term.`);
-    }
-
-    return termUnifies;
-  }
-
-  toJSON() {
-    const typeJSON = typeToTypeJSON(this.type),
-          provisionalJSON = provisionalToProvisionalJSON(this.provisional),
-          string = this.getString();
-
-    let breakPoint;
-
-    breakPoint = this.getBreakPoint();
-
-    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-    breakPoint = breakPointJSON;  ///
-
-    const type = typeJSON,  ///
-          provisional = provisionalJSON,  ///
-          json = {
-            string,
-            breakPoint,
-            type,
-            provisional
-          };
-
-    return json;
-  }
-
-  static name = "Term";
-
-  static fromJSON(json, context) {
-    return instantiate((context) => {
-      const { string } = json,
-            termNode = instantiateTerm(string, context),
-            node = termNode,  ///
-            breakPoint = breakPointFromJSON(json),
-            type = typeFromJSON(json, context),
-            provisional = provisionalFromJSON(json, context);
-
-      context = null;
-
-      const term = new Term(context, string, node, breakPoint, type, provisional);
-
-      return term;
-    }, context);
-  }
-});

package/src/element/topLevelAssertion/axiom.js

@@ -1,244 +0,0 @@
-"use strict";
-
-import { asynchronousUtilities } from "occam-languages";
-
-import TopLevelAssertion from "../topLevelAssertion";
-
-import { define } from "../../elements";
-import { reconcile } from "../../utilities/context";
-
-const { asyncMatch } = asynchronousUtilities;
-
-export default define(class Axiom extends TopLevelAssertion {
-  getAxiomNode() {
-    const node = this.getNode(),
-          axiomNode = node; ///
-
-    return axiomNode;
-  }
-
-  isSatisfiable() {
-    const signature = this.getSignature(),
-          satisfiable = (signature !== null);
-
-    return satisfiable;
-  }
-
-  async verify(context) {
-    let verifies;
-
-    await this.break(context);
-
-    const axiomString = this.getString(); ///
-
-    context.trace(`Verifying the '${axiomString}' axiom...`);
-
-    const signatureVerifies = this.verifySignature(context);
-
-    if (signatureVerifies) {
-      verifies = await super.verify(context);
-    }
-
-    if (verifies) {
-      const axiom = this; ///
-
-      context.addAxiom(axiom);
-
-      context.debug(`...verified the '${axiomString}' axiom.`);
-    }
-
-    return verifies;
-  }
-
-  verifySignature(context) {
-    let signatureVerifies;
-
-    const satisfiable = this.isSatisfiable();
-
-    if (satisfiable) {
-      const axiomString = this.getString(); ///
-
-      context.trace(`Verifying the '${axiomString}' axiom's signature...`);
-
-      const signature = this.getSignature();
-
-      signatureVerifies = signature.verify(context);
-
-      if (signatureVerifies) {
-        context.trace(`...verified the '${axiomString}' axiom's signature.`);
-      }
-    } else {
-      signatureVerifies = true
-    }
-
-    return signatureVerifies;
-  }
-
-  unifySignature(signature, context) {
-    let signatureUnifies;
-
-    const axiomString = this.getString(), ///
-          signatureString = signature.getString();
-
-    context.trace(`Unifying the '${signatureString}' signature with the '${axiomString}' axiom...`);
-
-    const specificSignature = signature;  ///
-
-    signature = this.getSignature();
-
-    const generalSignature = signature; ///
-
-    signatureUnifies = generalSignature.unifySignature(specificSignature, context);
-
-    if (signatureUnifies) {
-      context.debug(`...unified the '${signatureString}' signature with the '${axiomString}' axiom.`);
-    }
-
-    return signatureUnifies;
-  }
-
-  async unifyDeduction(deduction, context) {
-    let deductionUnifies;
-
-    await this.break(context);
-
-    const axiomString = this.getString(), ///
-          generalDeduction = this.deduction,  ///
-          specificDeduction = deduction,  ///
-          generalDeductionString = generalDeduction.getString(),
-          specificDeductionString = specificDeduction.getString();
-
-    context.trace(`Unifying the '${specificDeductionString}' deduction with the '${axiomString}' axiom's '${generalDeductionString}' deduction...`);
-
-    const generalDeductionContext = generalDeduction.getContext(),
-          specificDeductionContext = specificDeduction.getContext(),
-          generalContext = generalDeductionContext, ///
-          specificContext = specificDeductionContext; ///
-
-    reconcile((specificContext) => {
-      let statement;
-
-      statement = specificDeduction.getStatement();
-
-      const specificStatement = statement;  ///
-
-      statement = generalDeduction.getStatement();
-
-      const generalStatement = statement, ///
-            statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
-
-      if (statementUnifies) {
-        specificContext.commit(context);
-
-        deductionUnifies = true;
-      }
-    }, specificContext);
-
-    if (deductionUnifies) {
-      context.debug(`...unified the '${specificDeductionString}' deduction with the '${axiomString}' axiom's '${generalDeductionString}' deduction.`);
-    }
-
-    return deductionUnifies;
-  }
-
-  async unifySupposition(supposition, index, context) {
-    let suppositionUnifies = false;
-
-    const specificSupposition = supposition;  ///
-
-    supposition = this.getSupposition(index);
-
-    const axiomString = this.getString(), ///
-          generalSupposition = supposition,  ///
-          generalSuppositionString = generalSupposition.getString(),
-          specificSuppositionString = specificSupposition.getString();
-
-    context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${axiomString}' axiom's '${generalSuppositionString}' supposition...`);
-
-    const generalSuppositionContext = generalSupposition.getContext(),
-          specificSuppositionContext = specificSupposition.getContext(),
-          generalContext = generalSuppositionContext, ///
-          specificContext = specificSuppositionContext; ///
-
-    reconcile((specificContext) => {
-      let statement;
-
-      statement = specificSupposition.getStatement();
-
-      const specificStatement = statement;  ///
-
-      statement = generalSupposition.getStatement();
-
-      const generalStatement = statement, ///
-            statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
-
-      if (statementUnifies) {
-        specificContext.commit(context);
-
-        suppositionUnifies = true;
-      }
-    }, specificContext);
-
-    if (suppositionUnifies) {
-      context.debug(`...unified the '${specificSuppositionString}' supposition with the '${axiomString}' axiom's '${generalSuppositionString}' supposition...`);
-    }
-
-    return suppositionUnifies;
-  }
-
-  async unifySuppositions(suppositions, context) {
-    let suppositionsUnify;
-
-    const specificSuppositions = suppositions;  ///
-
-    suppositions = this.getSuppositions();
-
-    const generalSuppositions = suppositions; ///
-
-    suppositionsUnify = await asyncMatch(generalSuppositions, specificSuppositions, async (generalSupposition, specificSupposition, index) => {
-      const supposition = specificSupposition,  ///
-            suppositionUnifies = await this.unifySupposition(supposition, index, context);
-
-      if (suppositionUnifies) {
-        return true;
-      }
-    });
-
-    return suppositionsUnify;
-  }
-
-  async unifyTopLevelAssertion(topLevelAssertion, context) {
-    let topLevelAssertionUnifies = false;
-
-    const axiomString = this.getString(), ///
-          topLevelAssertionString = topLevelAssertion.getString();
-
-    context.trace(`Unifying the '${topLevelAssertionString}' top level assertion with the '${axiomString}' axiom...`);
-
-    const deduction = topLevelAssertion.getDeduction(),
-          deductionUnifies = await this.unifyDeduction(deduction, context);
-
-    if (deductionUnifies) {
-      const hypothesesDischarged = await topLevelAssertion.dischargeHypotheses(context);
-
-      if (hypothesesDischarged) {
-        const suppositions = topLevelAssertion.getSuppositions(),
-              suppositionsUnify = await this.unifySuppositions(suppositions, context);
-
-        if (suppositionsUnify) {
-          topLevelAssertionUnifies = true;
-        }
-      }
-    }
-
-    if (topLevelAssertionUnifies) {
-      context.debug(`...unified the '${topLevelAssertionString}' top level assertion with the '${axiomString}' axiom.`);
-    }
-
-    return topLevelAssertionUnifies;
-  }
-
-  static name = "Axiom";
-
-  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Axiom, json, context); }
-});

package/src/element/topLevelAssertion/conjecture.js

@@ -1,40 +0,0 @@
-"use strict";
-
-import TopLevelAssertion from "../topLevelAssertion";
-
-import { define } from "../../elements";
-
-export default define(class Conjecture extends TopLevelAssertion {
-  getConjectureNode() {
-    const node = this.getNode(),
-          conjectureNode = node;  ///
-
-    return conjectureNode;
-  }
-
-  async verify(context) {
-    let verifies;
-
-    await this.break(context);
-
-    const conjectureString = this.getString();  ///
-
-    context.trace(`Verifying the '${conjectureString}' conjecture...`);
-
-    verifies = await super.verify(context);
-
-    if (verifies) {
-      const conjecture = this;  ///
-
-      context.addConjecture(conjecture);
-
-      context.debug(`...verified the '${conjectureString}' conjecture.`);
-    }
-
-    return verifies;
-  }
-
-  static name = "Conjecture";
-
-  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Conjecture, json, context); }
-});

package/src/element/topLevelAssertion/lemma.js

@@ -1,42 +0,0 @@
-"use strict";
-
-import TopLevelAssertion from "../topLevelAssertion";
-
-import { define } from "../../elements";
-
-export default define(class Lemma extends TopLevelAssertion {
-  getLemmaNode() {
-    const node = this.getNode(),
-          lemmaNode = node; ///
-
-    return lemmaNode;
-  }
-
-  async verify(context) {
-    let verifies;
-
-    await this.break(context);
-
-    const lemmaString = this.getString(); ///
-
-    (lemmaString === null) ?
-      context.trace(`Verifying a lemma...`) :
-        context.trace(`Verifying the '${lemmaString}' lemma...`);
-
-    verifies = await super.verify(context);
-
-    if (verifies) {
-      const lemma = this; ///
-
-      context.addLemma(lemma);
-
-      (lemmaString === null) ?
-        context.debug(`...verified a lemma.`) :
-          context.debug(`...verified the '${lemmaString}' lemma.`);
-    }
-
-    return verifies;
-  }
-
-  static name = "Lemma";
-});

package/src/element/topLevelAssertion/theorem.js

@@ -1,40 +0,0 @@
-"use strict";
-
-import TopLevelAssertion from "../topLevelAssertion";
-
-import { define } from "../../elements";
-
-export default define(class Theorem extends TopLevelAssertion {
-  getThoeremNode() {
-    const node = this.getNode(),
-          theoremNode = node; ///
-
-    return theoremNode;
-  }
-
-  async verify(context) {
-    let verifies;
-
-    await this.break(context);
-
-    const theoremString = this.getString();  ///
-
-    context.trace(`Verifying the '${theoremString}' theorem...`);
-
-    verifies = await super.verify(context);
-
-    if (verifies) {
-      const theorem = this; ///
-
-      context.addTheorem(theorem);
-
-      context.debug(`...verified the '${theoremString}' theorem.`);
-    }
-
-    return verifies;
-  }
-
-  static name = "Theorem";
-
-  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Theorem, json, context); }
-});