occam-verify-cli 0.0.1111 → 0.0.1114

package/src/statement/unqualified.js

@@ -1,166 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-import shim from "../shim";
-import LocalContext from "../context/local";
-
-import { trim } from "../utilities/string";
-import { nodeQuery } from "../utilities/query";
-import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
-
-const { reverse } = arrayUtilities;
-
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement");
-
-class UnqualifiedStatement {
-  constructor(string, statement) {
-    this.string = string;
-    this.statement = statement;
-  }
-
-  getString() {
-    return this.string;
-  }
-
-  getStatement() {
-    return this.statement;
-  }
-
-  matchStatementNode(statementNode) { return this.statement.matchStatementNode(statementNode); }
-
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
-    let statementUnified;
-
-    const statementString = statement.getString(),
-          unqualifiedStatement = this,  ///
-          unqualifiedStatementString = unqualifiedStatement.getString();  ///
-
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement...`);
-
-    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
-
-    if (statementUnified) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement.`);
-    }
-
-    return statementUnified;
-  }
-
-  unifyIndependently(substitutions, generalContext, specificContext) {
-    let unifiedIndependently;
-
-    const unqualifiedStatement = this,  ///
-          unqualifiedStatementString = unqualifiedStatement.getString();  ///
-
-    specificContext.trace(`Unifying the '${unqualifiedStatementString}' unqualified statement independently...`);
-
-    const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
-
-    unifiedIndependently = statementResolvedIndependently;  ///
-
-    if (unifiedIndependently) {
-      specificContext.debug(`...unified the '${unqualifiedStatementString}' unqualified statement independently.`);
-    }
-
-    return unifiedIndependently;
-  }
-
-  unifyStatementWithProofSteps(statement, assignments, stated, context) {
-    let statementUnifiedWithProofSteps;
-
-    let proofSteps = context.getProofSteps();
-
-    proofSteps = reverse(proofSteps); ///
-
-    statementUnifiedWithProofSteps = proofSteps.some((proofStep) => {
-      const statementUnified = proofStep.unifyStatement(statement, context);
-
-      if (statementUnified) {
-        return true;
-      }
-    });
-
-    return statementUnifiedWithProofSteps;
-  }
-
-  verify(assignments, stated, context) {
-    let verified;
-
-    const unqualifiedStatement = this,  ///
-          unqualifiedStatementString = unqualifiedStatement.getString();  ///
-
-    if (this.statement !== null) {
-      context.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`);
-
-      const statementVerified = this.statement.verify(assignments, stated, context);
-
-      if (statementVerified) {
-        verified = true;
-      } else {
-        const statementUnifiedWithProofSteps = this.unifyStatementWithProofSteps(this.statement, assignments, stated, context);
-
-        if (statementUnifiedWithProofSteps) {
-          verified = true;
-        }
-      }
-
-      if (verified) {
-        context.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`);
-      }
-    } else {
-      context.debug(`Cannot verify the '${unqualifiedStatementString}' unqualified statement because it is nonsense.`);
-    }
-
-    return verified;
-  }
-
-  toJSON() {
-    const statementJSON = statementToStatementJSON(this.statement),
-          statement = statementJSON,  ///
-          string = this.string, ///
-          json = {
-            string,
-            statement
-          };
-
-    return json;
-  }
-
-  static fromJSON(json, fileContext) {
-    const { string } = json,
-          statement = statementFromJSON(json, fileContext),
-          unqualifiedStatement = new UnqualifiedStatement(string, statement);
-
-    return unqualifiedStatement;
-  }
-
-  static fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext) {
-    let unqualifiedStatement = null;
-
-    if (unqualifiedStatementNode !== null) {
-      let string;
-
-      const { Statement } = shim,
-            statementNode = statementNodeQuery(unqualifiedStatementNode),
-            localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext, ///
-            statement = Statement.fromStatementNode(statementNode, context),
-            node = unqualifiedStatementNode;  ///
-
-      string = fileContext.nodeAsString(node);
-
-      string = trim(string);  ///
-
-      unqualifiedStatement = new UnqualifiedStatement(string, statement);
-    }
-
-    return unqualifiedStatement;
-  }
-}
-
-Object.assign(shim, {
-  UnqualifiedStatement
-});
-
-export default UnqualifiedStatement;

package/src/supposition.js

@@ -1,183 +0,0 @@
-"use strict";
-
-import shim from "./shim";
-
-import { nodeQuery } from "./utilities/query";
-import { assignAssignments } from "./utilities/assignments";
-import { subproofAssertionFromStatement } from "./utilities/verification";
-import { unqualifiedStatementFromJSON, unqualifiedStatementToUnqualifiedStatementJSON } from "./utilities/json";
-
-const unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement");
-
-class Supposition {
-  constructor(unqualifiedStatement) {
-    this.unqualifiedStatement = unqualifiedStatement;
-  }
-
-  getUnqualifiedStatement() {
-    return this.unqualifiedStatement;
-  }
-
-  getString() { return this.unqualifiedStatement.getString(); }
-
-  getStatement() { return this.unqualifiedStatement.getStatement(); }
-
-  unifyIndependently(substitutions, generalContext, specificContext) {
-    let unifiedIndependently;
-
-    const supposition = this, ///
-          suppositionString = supposition.getString();
-
-    specificContext.trace(`Unifying the '${suppositionString}' supposition independently...`);
-
-    const unqualifiedStatementResolvedIndependently = this.unqualifiedStatement.unifyIndependently(substitutions, generalContext, specificContext);
-
-    unifiedIndependently = unqualifiedStatementResolvedIndependently;  ///
-
-    if (unifiedIndependently) {
-      specificContext.trace(`...unified the '${suppositionString}' supposition independently.`);
-    }
-
-    return unifiedIndependently;
-  }
-
-  unifyProofStep(proofStep, substitutions, generalContext, specificContext) {
-    let proofStepUnified = false;
-
-    const subproof = proofStep.getSubproof(),
-          statement = proofStep.getStatement();
-
-    substitutions.snapshot();
-
-    let subproofUnified = false,
-        statementUnified = false;
-
-    if (false) {
-      ///
-    } else if (subproof !== null) {
-      subproofUnified = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
-    } else if (statement !== null) {
-      statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
-    }
-
-    if (subproofUnified || statementUnified) {
-      substitutions.resolve(generalContext, specificContext);
-
-      proofStepUnified = true;
-    }
-
-    const context = specificContext;  ///
-
-    proofStepUnified ?
-      substitutions.continue() :
-        substitutions.rollback(context);
-
-    return proofStepUnified;
-  }
-
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
-    let statementUnified;
-
-    const supposition = this, ///
-          suppositionString = supposition.getString(),
-          statementString = statement.getString();
-
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
-
-    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, generalContext, specificContext);
-
-    if (statementUnified) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
-    }
-
-    return statementUnified;
-  }
-
-  unifySubproof(subproof, substitutions, generalContext, specificContext) {
-    let subproofUnified = false;
-
-    const supposition = this, ///
-          subproofString = subproof.getString(),
-          suppositionStatement = supposition.getStatement(),
-          suppositionStatementString = suppositionStatement.getString();
-
-    specificContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
-
-    const context = generalContext, ///
-          statement = this.unqualifiedStatement.getStatement(),
-          subproofAssertion = subproofAssertionFromStatement(statement, context);
-
-    if (subproofAssertion !== null) {
-      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
-    }
-
-    if (subproofUnified) {
-      specificContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
-    }
-
-    return subproofUnified;
-  }
-
-  verify(context) {
-    let verified = false;
-
-    const suppositionString = this.getString(); ///
-
-    context.trace(`Verifying the '${suppositionString}' supposition...`);
-
-    const stated = true,
-          assignments = [],
-          unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, context);
-
-    if (unqualifiedStatementVerified) {
-      const assignmentsAssigned = assignAssignments(assignments, context);
-
-      if (assignmentsAssigned) {
-        const { ProofStep } = shim,
-              proofStep = ProofStep.fromUnqualifiedStatement(this.unqualifiedStatement);
-
-        context.addProofStep(proofStep);
-
-        verified = true;
-      }
-    }
-
-    if (verified) {
-      context.debug(`...verified the '${suppositionString}' supposition.`);
-    }
-
-    return verified;
-  }
-
-  toJSON() {
-    const unqualifiedStatementJSON = unqualifiedStatementToUnqualifiedStatementJSON(this.unqualifiedStatement),
-          unqualifiedStatement = unqualifiedStatementJSON,  ///
-          json = {
-            unqualifiedStatement
-          };
-
-    return json;
-  }
-
-  static fromJSON(json, fileContext) {
-    const unqualifiedStatement = unqualifiedStatementFromJSON(json, fileContext),
-          supposition = new Supposition(unqualifiedStatement);
-
-    return supposition;
-  }
-
-  static fromSuppositionNode(suppositionNode, fileContext) {
-    const { UnqualifiedStatement } = shim,
-          unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
-          unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          supposition = new Supposition(unqualifiedStatement);
-
-    return supposition
-  }
-}
-
-Object.assign(shim, {
-  Supposition
-});
-
-export default Supposition;

package/src/utilities/equivalences.js

@@ -1,183 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-import Equivalence from "../equivalence";
-
-const { push, compress, separate } = arrayUtilities;
-
-export function mergeEquivalences(equivalencesA, equivalencesB) {
-  const typesA = typesFromEquivalences(equivalencesA),
-        typesB = typesFromEquivalences(equivalencesB),
-        types = [
-          ...typesA,
-          ...typesB
-        ];
-
-  compress(types, (typeA, typeB) => {
-    if (typeA === typeB) {
-      return true;
-    }
-  });
-
-  const equivalences = types.map((type) => {
-    let equivalence;
-
-    const equivalenceA = findEquivalenceByType(equivalencesA, type),
-          equivalenceB = findEquivalenceByType(equivalencesB, type);
-
-    if ((equivalenceA !== null) && (equivalenceB !== null)) {
-      const leftEquivalence = equivalenceA, ///
-            rightEquivalence = equivalenceB;  ///
-
-      equivalence = Equivalence.merge(leftEquivalence, rightEquivalence);
-    } else if (equivalenceA !== null) {
-      equivalence = equivalenceA; ///
-    } else if (equivalenceB !== null) {
-      equivalence = equivalenceB; ///
-    }
-
-    return equivalence;
-  });
-
-  return equivalences;
-}
-
-export function findEquivalenceByType(equivalences, type) {
-  const equivalence = equivalences.find((equivalence) => {
-    const equivalenceMatchesType = equivalence.matchType(type);
-
-    if (equivalenceMatchesType) {
-      return true;
-    }
-  }) || null;
-
-  return equivalence;
-}
-
-export function findEquivalenceByTerm(equivalences, term) {
-  const equivalence = equivalences.find((equivalence) => {
-    const termEquates = equivalence.equateTerm(term);
-
-    if (termEquates) {
-      return true;
-    }
-  }) || null;
-
-  return equivalence;
-}
-
-export function findEquivalenceByTermNodes(equivalences, termNodes) {
-  const equivalence = equivalences.find((equivalence) => {
-    const equivalenceMatchesTerms = equivalence.matchTermNodes(termNodes);
-
-    if (equivalenceMatchesTerms) {
-      return true;
-    }
-  }) || null;
-
-  return equivalence;
-}
-
-export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context) {
-  let groundedEquivalences,
-      remainingEquivalences,
-      initiallyGroundedEquivalences,
-      implicitlyGroundedEquivalences;
-
-  remainingEquivalences = [];
-
-  initiallyGroundedEquivalences = [];
-
-  separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context);
-
-  const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.length;
-
-  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 = [];
-
-      separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context);
-
-      push(groundedEquivalences, implicitlyGroundedEquivalences);
-
-      implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.length;  ///
-    }
-  }
-}
-
-function typesFromEquivalences(equivalences) {
-  const types = equivalences.map((equivalence) => {
-    const type = equivalence.getType();
-
-    return type;
-  });
-
-  return types;
-}
-
-function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
-  const terms = groundedTerms,  ///
-        variables = definedVariables; ///
-
-  terms.forEach((term) => {
-    const termVariables = term.getVariables(context);
-
-    termVariables.forEach((termVariable) => {
-      const variablesIncludesTermVariable = variables.includes(termVariable);
-
-      if (!variablesIncludesTermVariable) {
-        const variable = termVariable;  ///
-
-        variables.push(variable);
-      }
-    });
-  });
-}
-
-function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context) {
-  separate(equivalences, remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
-    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(context);
-
-    if (!equivalenceInitiallyGrounded) {
-      return true;
-    }
-  });
-}
-
-function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context) {
-  separate(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, (equivalence) => {
-    const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, context);
-
-    if (!equivalenceImplicitlyGrounded) {
-      return true;
-    }
-  });
-}
-
-function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context) {
-  groundedEquivalences.forEach((groundedEquivalence) => {
-    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, context);
-  });
-}