occam-verify-cli 1.0.800 → 1.0.809

package/src/context/synthetic.js

@@ -1,180 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-import Context from "../context";
-
-const { last } = arrayUtilities;
-
-export default class SyntheticContext extends Context {
-  constructor(context, contexts) {
-    super(context);
-
-    this.contexts = contexts;
-  }
-
-  getContexts() {
-    return this.contexts;
-  }
-
-  addSubstitutions(substitutions) {
-    const context = this.getContext();
-
-    context.addSubstitutions(substitutions);
-  }
-
-  findTermByTermNode(termNode) {
-    let term = null;
-
-    this.contexts.some((context) => {
-      term = context.findTermByTermNode(termNode);
-
-      if (term !== null) {
-        return true;
-      }
-    });
-
-    return term;
-  }
-
-  findFrameByFrameNode(frameNode) {
-    let frame = null;
-
-    this.contexts.some((context) => {
-      frame = context.findFrameByFrameNode(frameNode);
-
-      if (frame !== null) {
-        return true;
-      }
-    });
-
-    return frame;
-  }
-
-  findStatementByStatementNode(statementNode) {
-    let statement = null;
-
-    this.contexts.some((context) => {
-      statement = context.findStatementByStatementNode(statementNode);
-
-      if (statement !== null) {
-        return true;
-      }
-    });
-
-    return statement;
-  }
-
-  findSubstitutionBySubstitutionNode(substitutionNode) {
-    let substitution = null;
-
-    this.contexts.some((context) => {
-      substitution = context.findSubstitutionBySubstitutionNode(substitutionNode);
-
-      if (substitution !== null) {
-        return true;
-      }
-    });
-
-    return substitution;
-  }
-
-  findReferenceByMetavariableNode(metavariableNode) {
-    let reference = null;
-
-    this.contexts.some((context) => {
-      reference = context.findReferenceByMetavariableNode(metavariableNode);
-
-      if (reference !== null) {
-        return true;
-      }
-    });
-
-    return reference;
-  }
-
-  findVariableByVariableIdentifier(variableIdentifier) {
-    let variable = null;
-
-    this.contexts.some((context) => {
-      variable = context.findVariableByVariableIdentifier(variableIdentifier);
-
-      if (variable !== null) {
-        return true;
-      }
-    });
-
-    return variable;
-  }
-
-  findMetavariableByMetavariableName(metavariableName) {
-    let metavariable = null;
-
-    this.contexts.some((context) => {
-      metavariable = context.findMetavariableByMetavariableName(metavariableName);
-
-      if (metavariable !== null) {
-        return true;
-      }
-    });
-
-    return metavariable;
-  }
-
-  isTermPresentByTermNode(termNode) {
-    const term = this.findTermByTermNode(termNode),
-          termPresent = (term !== null);
-
-    return termPresent;
-  }
-
-  isFramePresentByFrameNode(frameNode) {
-    const frame = this.findFrameByFrameNode(frameNode),
-          framePresent = (frame !== null);
-
-    return framePresent;
-  }
-
-  isStatementPresentByStatementNode(statementNode) {
-    const statement = this.findStatementByStatementNode(statementNode),
-          statementPresent = (statement !== null);
-
-    return statementPresent;
-  }
-
-  isSubstitutionPresentBySubstitutionNode(substitutionNode) {
-    const substitution = this.findSubstitutionBySubstitutionNode(substitutionNode),
-      substitutionPresent = (substitution !== null);
-
-    return substitutionPresent;
-  }
-
-  isReferencePresentByMetavariableNode(metavariableNode) {
-    const reference = this.findReferenceByMetavariableNode(metavariableNode),
-          referencePresent = (reference !== null);
-
-    return referencePresent;
-  }
-
-  isVariablePresentByVariableIdentifier(variableIdentifier) {
-    const variable = this.findVariableByVariableIdentifier(variableIdentifier),
-          variablePresent = (variable !== null);
-
-    return variablePresent;
-  }
-
-  isMetavariablePresentByMetavariableName(metavariableName) {
-    const metavariable = this.findMetavariableByMetavariableName(metavariableName),
-          metavariablePresent = (metavariable !== null);
-
-    return metavariablePresent;
-  }
-
-  static fromContexts(...contexts) {
-    const lastContext = last(contexts),
-          context = lastContext,  ///
-          syntheticContext = new SyntheticContext(context, contexts);
-
-    return syntheticContext;
-  }
-}

package/src/element/equivalences.js

@@ -1,237 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-import { arrayUtilities } from "necessary";
-
-import { define } from "../elements";
-import { EMPTY_STRING } from "../constants";
-import { variablesFromTerm } from "../utilities/equivalence";
-
-const { push, separate } = arrayUtilities;
-
-export default define(class Equivalences extends Element {
-  constructor(context, string, node, array) {
-    super(context, string, node);
-
-    this.array = array;
-  }
-
-  getArray() {
-    return this.array;
-  }
-
-  getEquivalencesNode() {
-    const node = this.getNode(),
-          equivalencesNode = node;  ///
-
-    return equivalencesNode;
-  }
-
-  getLength() { return this.array.length; }
-
-  getTypes() {
-    const types = this.array.map((equivalence) => {
-      const type = equivalence.getType();
-
-      return type;
-    });
-
-    return types;
-  }
-
-  addEquivalence(equivalence) {
-    this.array.push(equivalence);
-  }
-
-  addEquivalences(equivalences) {
-    const array = equivalences.getArray();
-
-    push(this.array, array);
-  }
-
-  someEquivalence(callback) { return this.array.some(callback); }
-
-  everyEquivalence(callback) { return this.array.every(callback); }
-
-  forEachEquivalence(callback) { this.array.forEach(callback); }
-
-  findEquivalenceByTerm(term) {
-    const equivalence = this.array.find((equivalence) => {
-      const equivalenceComparesToTerm = equivalence.compareTerm(term);
-
-      if (equivalenceComparesToTerm) {
-        return true;
-      }
-    }) || null;
-
-    return equivalence;
-  }
-
-  findEquivalenceByTermNodes(termNodes) {
-    const equivalence = this.array.find((equivalence) => {
-      const termNodeMatches = equivalence.matchTermNodes(termNodes);
-
-      if (termNodeMatches) {
-        return true;
-      }
-    }) || null;
-
-    return equivalence;
-  }
-
-  mergedWith(equivalences, context) {
-    let  mergedEquivalences = this.clone(context); ///
-
-    equivalences.forEachEquivalence((equivalence) => {
-      mergedEquivalences = mergedEquivalences.mergedWithEquivalence(equivalence, context);
-    });
-
-    return mergedEquivalences;
-  }
-
-  mergedWithEquivalence(equivalence, context) {
-    const equivalences = Equivalences.fromNothing(context);
-
-    let mergedEquivalence = equivalence; ///
-
-    this.forEachEquivalence((equivalence) => {
-      const mergedEquivalenceDisjointFromEquivalence = mergedEquivalence.isDisjointFrom(equivalence);
-
-      if (mergedEquivalenceDisjointFromEquivalence) {
-        equivalences.addEquivalence(equivalence);
-      } else {
-        mergedEquivalence = mergedEquivalence.mergedWith(equivalence, context);
-      }
-    });
-
-    equivalence = mergedEquivalence;  ///
-
-    equivalences.addEquivalence(equivalence);
-
-    return equivalences;
-  }
-
-  separateEquivalences(equivalencesA, equivalencesB, callback) {
-    const equivalencesAArray = equivalencesA.getArray(),
-          equivalencesBArray = equivalencesB.getArray();
-
-    separate(this.array, equivalencesAArray, equivalencesBArray, callback);
-  }
-
-  separateInitiallyGroundedEquivalences(remainingEquivalences, initiallyGroundedEquivalences, context) {
-    this.separateEquivalences(remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
-      const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(context);
-
-      if (!equivalenceInitiallyGrounded) {
-        return true;
-      }
-    });
-  }
-
-  separateImplicitlyGroundedEquivalences(remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context) {
-    this.separateEquivalences(remainingEquivalences, implicitlyGroundedEquivalences, (equivalence) => {
-      const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, context);
-
-      if (!equivalenceImplicitlyGrounded) {
-        return true;
-      }
-    });
-  }
-
-  separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context) {
-    let equivalences = this,  ///
-        groundedEquivalences,
-        remainingEquivalences,
-        initiallyGroundedEquivalences,
-        implicitlyGroundedEquivalences;
-
-    remainingEquivalences =Equivalences.fromNothing(context);
-
-    initiallyGroundedEquivalences = Equivalences.fromNothing(context);
-
-    equivalences.separateInitiallyGroundedEquivalences(remainingEquivalences, initiallyGroundedEquivalences, context);
-
-    const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.getLength();
-
-    if (initiallyGroundedEquivalencesLength > 0) {
-      groundedEquivalences = initiallyGroundedEquivalences; ///
-
-      let implicitlyGroundedEquivalencesLength = 1;
-
-      while (implicitlyGroundedEquivalencesLength > 0) {
-        let definedVariablesLength = 0,
-            previousDefinedVariablesLength = -1;
-
-        while (definedVariablesLength > previousDefinedVariablesLength) {
-          previousDefinedVariablesLength = definedVariablesLength;  ///
-
-          groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context);
-
-          definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context);
-
-          definedVariablesLength = definedVariables.length;
-        }
-
-        equivalences = remainingEquivalences; ///
-
-        remainingEquivalences = [];
-
-        implicitlyGroundedEquivalences = [];
-
-        equivalences.separateImplicitlyGroundedEquivalences(remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context);
-
-        groundedEquivalences.addEquivalences(implicitlyGroundedEquivalences);
-
-        implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.getLength();  ///
-      }
-    }
-  }
-
-  clone(context) {
-    const string = EMPTY_STRING,
-          node = null,
-          array = [
-            ...this.array
-          ],
-          equivalences = new Equivalences(context, string, node, array);
-
-    return equivalences;
-  }
-
-  static name = "Equivalences";
-
-  static fromNothing(context) {
-    const string = EMPTY_STRING,
-          node = null,
-          array = [];
-
-    context = null;
-
-    const equivalences = new Equivalences(context, string, node, array);
-
-    return equivalences;
-  }
-});
-
-function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
-  groundedTerms.forEach((groundedTerm) => {
-    const term = groundedTerm,  ///
-          variables = variablesFromTerm(term, context);
-
-    variables.forEach((variable) => {
-      const definedVariablesIncludesTermVariable = definedVariables.includes(variable);
-
-      if (!definedVariablesIncludesTermVariable) {
-        const definedVariable = variable;  ///
-
-        definedVariables.push(definedVariable);
-      }
-    });
-  });
-}
-
-function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context) {
-  groundedEquivalences.forEachEquivalence((groundedEquivalence) => {
-    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, context);
-  });
-}