occam-verify-cli 1.0.984 → 1.0.985

package/src/element/assumption.js

@@ -1,374 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-import { define } from "../elements";
-import { instantiateAssumption } from "../process/instantiate";
-import { reconcile, instantiate } from "../utilities/context";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-
-export default define(class Assumption extends Element {
-  constructor(context, string, node, breakPoint, reference, statement) {
-    super(context, string, node, breakPoint);
-
-    this.reference = reference;
-    this.statement = statement;
-  }
-
-  getReference() {
-    return this.reference;
-  }
-
-  getStatement() {
-    return this.statement;
-  }
-
-  getAssumptionNode() {
-    const node = this.getNode(),
-          assumptionNode = node;  ///
-
-    return assumptionNode;
-  }
-
-  getStatementNode() { return this.statement.getStatementNode(); }
-
-  getMetavariable() { return this.reference.getMetavariable(); }
-
-  getTopLevelMetaAssertion() { return this.reference.getTopLevelMetaAssertion(); }
-
-  isEqualTo(assumption) {
-    const assumptionNode = assumption.getNode(),
-          assumptionNodeMatches = this.matchAssumptionNode(assumptionNode),
-          equalTo = assumptionNodeMatches;  ///
-
-    return equalTo;
-  }
-
-  matchAssumptionNode(assumptionNode) {
-    const node = assumptionNode, ///
-          nodeMatches = this.matchNode(node),
-          assumptionNodeMatches = nodeMatches; ///
-
-    return assumptionNodeMatches;
-  }
-
-  findSubproofAssertion(context) {
-    let subproofAssertion = null;
-
-    const statementNode = this.getStatementNode(),
-          subproofAssertionNode = statementNode.getSubproofAssertionNode();
-
-    if (subproofAssertionNode !== null) {
-      subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
-    }
-
-    return subproofAssertion;
-  }
-
-  findValidAssumption(context) {
-    const assumptionNode = this.getAssumptionNode(),
-          assumption = context.findAssumptionByAssumptionNode(assumptionNode),
-          validAssumption = assumption;  ///
-
-    return validAssumption;
-  }
-
-  validate(context) {
-    let assumption = null;
-
-    const assumptionString = this.getString();  ///
-
-    context.trace(`Validating the '${assumptionString}' assumption...`);
-
-    let validates = false;
-
-    const validAssumption = this.findValidAssumption(context);
-
-    if (validAssumption) {
-      validates = true;
-
-      assumption = validAssumption; ///
-
-      context.debug(`...the '${assumptionString}' assumption is already valid.`);
-    } else {
-      const statementValidates = this.validateStatement(context);
-
-      if (statementValidates) {
-        const referenceValidates = this.validateReference(context);
-
-        if (referenceValidates) {
-          const stated = context.isStated();
-
-          let validatesWhenStated = false,
-              validatesWhenDerived = false;
-
-          if (stated) {
-            validatesWhenStated = this.validateWhenStated(context);
-          } else {
-            validatesWhenDerived = this.validateWhenDerived(context);
-          }
-
-          if (validatesWhenStated || validatesWhenDerived) {
-            validates = true;
-          }
-        }
-      }
-
-      if (validates) {
-        assumption = this;  ///
-
-        context.addAssumption(assumption);
-      }
-    }
-
-    if (validates) {
-      context.debug(`...validated the '${assumptionString}' assumption.`);
-    }
-
-    return assumption;
-  }
-
-  validateReference(context) {
-    let referenceValidates = false;
-
-    const assumptionString = this.getString();  ///
-
-    context.trace(`Validating the '${assumptionString}' assumption's reference...`);
-
-    const reference = this.reference.validate(context);
-
-    if (reference !== null) {
-      const metavariable = reference.getMetavariable(),
-            metavariablePresent = context.isMetavariablePresent(metavariable, context);
-
-      if (metavariablePresent) {
-        this.reference = reference;
-
-        referenceValidates = true;
-      } else {
-        const topLevelMetaAssertionsUnify = this.unifyTopLevelMetaAssertions(reference, context);
-
-        if (topLevelMetaAssertionsUnify) {
-          this.reference = reference;
-
-          referenceValidates = true;
-        }
-      }
-    }
-
-    if (referenceValidates) {
-      context.debug(`...validated the '${assumptionString}' assumption's reference.`);
-    }
-
-    return referenceValidates;
-  }
-
-  validateStatement(context) {
-    let statementValidates = false;
-
-    const assumptionString = this.getString();  ///
-
-    context.trace(`Validating the '${assumptionString}' assumption's statement...`);
-
-    const statement = this.statement.validate(context);
-
-    if (statement !== null) {
-      statementValidates = true;
-    }
-
-    if (statementValidates) {
-      context.debug(`...validated the '${assumptionString}' assumption's statement.`);
-    }
-
-    return statementValidates;
-  }
-
-  validateWhenStated(context) {
-    let validatesWhenStated;
-
-    const assumptionString = this.getString();  ///
-
-    context.trace(`Validating the '${assumptionString}' stated assumption...`);
-
-    validatesWhenStated = true
-
-    if (validatesWhenStated) {
-      context.debug(`...validated the '${assumptionString}' stated assumption.`);
-    }
-
-    return validatesWhenStated;
-  }
-
-  validateWhenDerived(context) {
-    let validatesWhenDerived = false;
-
-    const assumptionString = this.getString();  ///
-
-    context.trace(`Validating the '${assumptionString}' derived assumption...`);
-
-    const topLevelMetaAssertion = this.getTopLevelMetaAssertion();
-
-    if (topLevelMetaAssertion !== null) {
-      validatesWhenDerived = true;
-    } else {
-      context.debug(`The '${assumptionString}' asumption did not unify a top level meta-assumption.`);
-    }
-
-    if (validatesWhenDerived) {
-      context.debug(`...validated the '${assumptionString}' derived assumption.`);
-    }
-
-    return validatesWhenDerived;
-  }
-
-  unifyStatement(statement, generalContext, specificContext) {
-    let statementUnifies;
-
-    const context = specificContext, ///
-          statementString = statement.getString(),
-          proofAssertionString = this.getString();  ///
-
-    context.trace(`Unifying the '${statementString}' statement with the '${proofAssertionString}' assumption's statement...`);
-
-    statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
-
-    if (statementUnifies) {
-      context.debug(`...unified the '${statementString}' statement with the '${proofAssertionString}' assumption's statement.`);
-    }
-
-    return statementUnifies;
-  }
-
-  unifyDeduction(deduction, context) {
-    let deductionUnifies = false;
-
-    const deductionString = deduction.getString(),
-          assumptionString = this.getString();  ///
-
-    context.trace(`Unifying the '${deductionString}' deduction with the '${assumptionString}' assumption's statement...`);
-
-    const deductionContext = deduction.getContext(),
-          generalContext = context, ///
-          specificContext = deductionContext; ///
-
-    reconcile((specificContext) => {
-      const statement = deduction.getStatement(),
-            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
-
-      if (statementUnifies) {
-        specificContext.commit(context);
-
-        deductionUnifies = true;
-      }
-    }, specificContext);
-
-    if (deductionUnifies) {
-      context.debug(`...unified the '${deductionString}' deduction with the '${assumptionString}' assumption's statement.`);
-    }
-
-    return deductionUnifies;
-  }
-
-  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
-    let topLevelMetaAssertionUnifies = false;
-
-    const assumptionString = this.getString(),  ///
-          topLevelMetaAssertionString = topLevelMetaAssertion.getString();
-
-    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);
-
-    reconcile((context) => {
-      topLevelMetaAssertionUnifies = this.reference.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
-
-      if (topLevelMetaAssertionUnifies) {
-        const subproofAssertion = this.findSubproofAssertion(context);
-
-        if (subproofAssertion !== null) {
-          topLevelMetaAssertionUnifies = subproofAssertion.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
-        } else {
-          const unconditional = topLevelMetaAssertion.isUnconditional();
-
-          if (unconditional) {
-            const deduction = topLevelMetaAssertion.getDeduction(),
-                  deductionUnifies = this.unifyDeduction(deduction, context);
-
-            if (deductionUnifies) {
-              topLevelMetaAssertionUnifies = true;
-            }
-          }
-        }
-      }
-    }, context);
-
-    if (topLevelMetaAssertionUnifies) {
-      context.trace(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);
-    }
-
-    return topLevelMetaAssertionUnifies;
-  }
-
-  unifyTopLevelMetaAssertions(reference, context) {
-    let topLevelMetaAssertionsUnify;
-
-    const topLevelMetaAssertions = context.findTopLevelMetaAssertionsByReference(reference);
-
-    topLevelMetaAssertionsUnify = topLevelMetaAssertions.some((topLevelMetaAssertion) => {
-      const topLevelMetaAssertionUnifies = this.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
-
-      if (topLevelMetaAssertionUnifies) {
-        return true;
-      }
-    });
-
-    return topLevelMetaAssertionsUnify;
-  }
-
-  static name = "Assumption";
-
-  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,
-            assumptionNode = instantiateAssumption(string, context),
-            node = assumptionNode,  ///
-            breakPoint = breakPointFromJSON(json),
-            reference = referenceFromAssumptionNode(assumptionNode, context),
-            statement = statementFromAssumptionNode(assumptionNode, context),
-            assumption = new Assumption(context, string, node, breakPoint, reference, statement);
-
-      return assumption;
-    }, context);
-  }
-});
-
-function referenceFromAssumptionNode(assumptionNode, context) {
-  const metavariableNode = assumptionNode.getMetavariableNode(context),
-        reference = context.findReferenceByMetavariableNode(metavariableNode);
-
-  return reference;
-}
-
-function statementFromAssumptionNode(assumptionNode, context) {
-  const statementNode = assumptionNode.getStatementNode(),
-        statement = context.findStatementByStatementNode(statementNode);
-
-  return statement;
-}

package/src/element/combinator/bracketed.js

@@ -1,32 +0,0 @@
-"use strict";
-
-import Combinator from "../combinator";
-
-import { define } from "../../elements";
-
-export default define(class BracketedCombinator extends Combinator {
-  getBracketedCombinatorNode() {
-    const node = this.getNode(),
-          bracketedCombinatorNode = node; ///
-
-    return bracketedCombinatorNode;
-  }
-
-  unifyStatement(statement, context) {
-    let statementUnifies;
-
-    const statementString = statement.getString();
-
-    context.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`);
-
-    statementUnifies = super.unifyStatement(statement, context);
-
-    if (statementUnifies) {
-      context.debug(`...unified the '${statementString}' statement with the bracketed combinator.`);
-    }
-
-    return statementUnifies;
-  }
-
-  static name = "BracketedCombinator";
-});

package/src/element/combinator.js

@@ -1,145 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-import { define } from "../elements";
-import { instantiateCombinator } from "../process/instantiate";
-import { statementFromCombinatorNode } from "../utilities/element";
-import { unifyStatementWithCombinator } from "../process/unify";
-import { validateStatementAsCombinator } from "../process/validate";
-import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-
-export default define(class Combinator extends Element {
-  constructor(context, string, node, breakPoint, statement) {
-    super(context, string, node, breakPoint);
-
-    this.statement = statement;
-  }
-
-  getStatement() {
-    return this.statement;
-  }
-
-  getCombinatoryNode() {
-    const node = this.getNode(),
-          combinatorNode = node;  ///
-
-    return combinatorNode;
-  }
-
-  validate(context) {
-    let validates = false;
-
-    const combinatorString = this.getString();  ///
-
-    context.trace(`Validating the '${combinatorString}' combinator...`);
-
-    attempt((context) => {
-      const statementValidates = this.validateStatement(context);
-
-      if (statementValidates) {
-        validates = true;
-      }
-
-      if (validates) {
-        this.commit(context);
-      }
-    }, context)
-
-    if (validates) {
-      context.debug(`...validated the '${combinatorString}' combinator.`);
-    }
-
-    return validates;
-  }
-
-  validateStatement(context) {
-    let statementValidates = false;
-
-    const combinatorString = this.getString();  ///
-
-    context.trace(`Validating the '${combinatorString}' combinator's statement...`);
-
-    const statementValidatesAsCombinator = validateStatementAsCombinator(this.statement, context);
-
-    if (statementValidatesAsCombinator) {
-      statementValidates = true;
-    }
-
-    if (statementValidates) {
-      context.debug(`...validated the '${combinatorString}' combinator's statement.`);
-    }
-
-    return statementValidates;
-  }
-
-  unifyStatement(statement, context) {
-    let statementUnifies = false;
-
-    const statementString = statement.getString(),
-          combinatorString = this.getString();  ///
-
-    context.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`);
-
-    const combinator = this, ///
-          combinatorContext = combinator.getContext(),
-          generalContext = combinatorContext, ///
-          specifiContext = context, ///
-          statementUnifiesWithCombinator = unifyStatementWithCombinator(statement, combinator, generalContext, specifiContext);
-
-    if (statementUnifiesWithCombinator) {
-      statementUnifies = true;
-    }
-
-    if (statementUnifies) {
-      context.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`);
-    }
-
-    return statementUnifies;
-  }
-
-  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 name = "Combinator";
-
-  static fromJSON(json, context) {
-    let combinator;
-
-    instantiate((context) => {
-      unserialise((json, context) => {
-        const { string } = json,
-              combinatorNode = instantiateCombinator(string, context),
-              node = combinatorNode,  ///
-              breakPoint = breakPointFromJSON(json),
-              statement = statementFromCombinatorNode(combinatorNode, context);
-
-        combinator = new Combinator(context, string, node, breakPoint, statement);
-      }, json, context);
-    }, context);
-
-    return combinator;
-  }
-});