occam-verify-cli 0.0.1111 → 0.0.1112

package/src/mixins/statement/unifyIndependenntly.js

@@ -1,58 +0,0 @@
-"use strict";
-
-import { definedAssertionFromStatement, containedAssertionFromStatement } from "../../utilities/verification";
-
-function unifyIndependentlyAsDefinedAssertion(statement, substitutions, generalContext, specificContext) {
-  let unifiedIndependentlyAsDefinedAssertion = false;
-
-  const context = generalContext, ///
-        definedAssertion = definedAssertionFromStatement(statement, context);
-
-  if (definedAssertion !== null) {
-    const statementString = statement.getString();
-
-    specificContext.trace(`Unifying the '${statementString}' statement as a defined assertion independently...`);
-
-    const context = specificContext,  ///
-          definedAssertionUnifiedIndependently = definedAssertion.unifyIndependently(substitutions, context);
-
-    unifiedIndependentlyAsDefinedAssertion = definedAssertionUnifiedIndependently; ///
-
-    if (unifiedIndependentlyAsDefinedAssertion) {
-      specificContext.debug(`...unified the '${statementString}' statement as a defined assertion independently.`);
-    }
-  }
-
-  return unifiedIndependentlyAsDefinedAssertion;
-}
-
-function unifyIndependentlyAsContainedAssertion(statement, substitutions, generalContext, specificContext) {
-  let unifiedIndependentlyAsContainedAssertion = false;
-
-  const context = generalContext, ///
-        containedAssertion = containedAssertionFromStatement(statement, context);
-
-  if (containedAssertion !== null) {
-    const statementString = statement.getString();
-
-    specificContext.trace(`Unifying the '${statementString}' statement as a contained assertion independently...`);
-
-    const context = specificContext,  ///
-          containedAssertionUnifiedIndependently = containedAssertion.unifyIndependently(substitutions, context);
-
-    unifiedIndependentlyAsContainedAssertion = containedAssertionUnifiedIndependently; ///
-
-    if (unifiedIndependentlyAsContainedAssertion) {
-      specificContext.debug(`...unified the '${statementString}' statement as a contained assertion independently.`);
-    }
-  }
-
-  return unifiedIndependentlyAsContainedAssertion;
-}
-
-const unifyIndependentlyMixins = [
-  unifyIndependentlyAsDefinedAssertion,
-  unifyIndependentlyAsContainedAssertion
-];
-
-export default unifyIndependentlyMixins;

package/src/mixins/term/unify.js

@@ -1,36 +0,0 @@
-"use strict";
-
-import BracketedConstructor from "../../constructor/bracketed";
-
-function unifyWithBracketedConstructor(term, context, verifyAhead) {
-  let unifiedWithBracketedConstructor;
-
-  const bracketedConstructor = BracketedConstructor.fromNothing();
-
-  unifiedWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, verifyAhead);
-
-  return unifiedWithBracketedConstructor;
-}
-
-function unifyWithConstructors(term, context, verifyAhead) {
-  let unifiedWithConstructors;
-
-  const constructors = context.getConstructors();
-
-  unifiedWithConstructors = constructors.some((constructor) => {
-    const unifiedWithConstructor = constructor.unifyTerm(term, context, verifyAhead);
-
-    if (unifiedWithConstructor) {
-      return true;
-    }
-  });
-
-  return unifiedWithConstructors;
-}
-
-const unifyMixins = [
-  unifyWithBracketedConstructor,
-  unifyWithConstructors
-];
-
-export default unifyMixins;

package/src/premise.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("/premise/unqualifiedStatement");
-
-class Premise {
-  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 premise = this, ///
-          premiseString = premise.getString();
-
-    specificContext.trace(`Unifying the '${premiseString}' premise independently...`);
-
-    const unqualifiedStatementResolvedIndependently = this.unqualifiedStatement.unifyIndependently(substitutions, generalContext, specificContext);
-
-    unifiedIndependently = unqualifiedStatementResolvedIndependently;  ///
-
-    if (unifiedIndependently) {
-      specificContext.trace(`...unified the '${premiseString}' premise 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 premise = this, ///
-          premiseString = premise.getString(),
-          statementString = statement.getString();
-
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
-
-    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, generalContext, specificContext);
-
-    if (statementUnified) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
-    }
-
-    return statementUnified;
-  }
-
-  unifySubproof(subproof, substitutions, generalContext, specificContext) {
-    let subproofUnified = false;
-
-    const premise = this, ///
-          subproofString = subproof.getString(),
-          premiseStatement = premise.getStatement(),
-          premiseStatementString = premiseStatement.getString();
-
-    specificContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' 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 premise's '${premiseStatementString}' statement.`);
-    }
-
-    return subproofUnified;
-  }
-
-  verify(context) {
-    let verified = false;
-
-    const premiseString = this.getString(); ///
-
-    context.trace(`Verifying the '${premiseString}' premise...`);
-
-    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 '${premiseString}' premise.`);
-    }
-
-    return verified;
-  }
-
-  toJSON() {
-    const unqualifiedStatementJSON = unqualifiedStatementToUnqualifiedStatementJSON(this.unqualifiedStatement),
-          unqualifiedStatement = unqualifiedStatementJSON,  ///
-          json = {
-            unqualifiedStatement
-          };
-
-    return json;
-  }
-
-  static fromJSON(json, fileContext) {
-    const unqualifiedStatement = unqualifiedStatementFromJSON(json, fileContext),
-          premise = new Premise(unqualifiedStatement);
-
-    return premise;
-  }
-
-  static fromPremiseNode(suppositionNode, fileContext) {
-    const { UnqualifiedStatement } = shim,
-          unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
-          unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          premise = new Premise(unqualifiedStatement);
-
-    return premise
-  }
-}
-
-Object.assign(shim, {
-  Premise
-});
-
-export default Premise;

package/src/proofStep.js

@@ -1,181 +0,0 @@
-"use strict";
-
-import shim from "./shim";
-
-import { nodeQuery } from "./utilities/query";
-import { assignAssignments } from "./utilities/assignments";
-
-const subproofNodeQuery = nodeQuery("/proofStep/subproof"),
-      statementNodeQuery = nodeQuery("/proofStep|lastProofStep/statement"),
-      referenceNodeQuery = nodeQuery("/proofStep|lastProofStep/reference");
-
-class ProofStep {
-  constructor(subproof, statement, reference) {
-    this.subproof = subproof;
-    this.statement = statement;
-    this.reference = reference;
-  }
-
-  getSubproof() {
-    return this.subproof;
-  }
-
-  getQualifiedStatement() {
-    return this.qualifiedStatement;
-  }
-
-  getUnqualifiedStatement() {
-    return this.unqualifiedStatement;
-  }
-
-  getStatement() {
-    let statement = null;
-
-    if (this.qualifiedStatement !== null) {
-      statement = this.qualifiedStatement.getStatement();
-    }
-
-    if (this.unqualifiedStatement !== null) {
-      statement = this.unqualifiedStatement.getStatement();
-    }
-
-    return statement;
-  }
-
-  unifyStatement(statement, context) {
-    let statementUnified = false;
-
-    if ((this.qualifiedStatement !== null) || (this.unqualifiedStatement !== null)) {
-      const statementString = statement.getString();
-
-      context.trace(`Unifying the '${statementString}' statement...`);
-
-      const { Substitutions } = shim,
-            specificContext = context, ///
-            generalContext = context, ///
-            substitutions = Substitutions.fromNothing();
-
-      if (this.qualifiedStatement !== null) {
-        statementUnified = this.qualifiedStatement.unifyStatement(statement, substitutions, generalContext, specificContext);
-      }
-
-      if (this.unqualifiedStatement !== null) {
-        statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, generalContext, specificContext);
-      }
-
-      const substitutionsLength = substitutions.getLength();
-
-      if (substitutionsLength > 0) {
-        statementUnified = false;
-      }
-
-      if (statementUnified) {
-        context.debug(`...unified the '${statementString}' statement.`);
-      }
-    }
-
-    return statementUnified;
-  }
-
-  unifySubproofAssertion(subproofAssertion, context) {
-    let subproofAssertionUnified = false;
-
-    if (this.subproof !== null) {
-      const subproofAssertionString = subproofAssertion.getString();
-
-      context.trace(`Unifying the '${subproofAssertionString}' subproof assertion...`);
-
-      const { Substitutions } = shim,
-            specificContext = context, ///
-            generalContext = context, ///
-            substitutions = Substitutions.fromNothing();
-
-      subproofAssertionUnified = this.subproof.unifySubproofAssertion(subproofAssertion, substitutions, generalContext, specificContext);
-
-      if (subproofAssertionUnified) {
-        const substitutionsLength = substitutions.getLength();
-
-        if (substitutionsLength > 0) {
-          subproofAssertionUnified = false;
-        }
-      }
-
-      if (subproofAssertionUnified) {
-        context.debug(`...unified the '${subproofAssertionString}' subproof assertion.`);
-      }
-    }
-
-    return subproofAssertionUnified;
-  }
-
-  verify(substitutions, context) {
-    let verified = false;
-
-    let stated = false;
-
-    const assignments = [];
-
-    let subproofVerified = false,
-        qualifiedStatementVerified = false,
-        unqualifiedStatementVerified = false;
-
-    if (this.subproof !== null) {
-      subproofVerified = this.subproof.verify(substitutions, context);
-    }
-
-    if (this.qualifiedStatement !== null) {
-      stated = true;
-
-      qualifiedStatementVerified = this.qualifiedStatement.verify(substitutions, assignments, stated, context);
-    }
-
-    if (this.unqualifiedStatement !== null) {
-      stated = false;
-
-      unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, context);
-    }
-
-    if (subproofVerified || qualifiedStatementVerified || unqualifiedStatementVerified) {
-      const assignmentsAssigned = assignAssignments(assignments, context);
-
-      if (assignmentsAssigned) {
-        verified = true;
-      }
-    }
-
-    if (verified) {
-      const proofStep = this; ///
-
-      context.addProofStep(proofStep);
-    }
-
-    return verified;
-  }
-
-  static fromProofStepNode(proofStepNode, fileContext) {
-    const { Subproof, QualifiedStatement, UnqualifiedStatement } = shim,
-          subproofNode = subproofNodeQuery(proofStepNode),
-          qualifiedStatementNode = qualifiedStatementNodeQuery(proofStepNode),
-          unqualifiedStatementNode = unqualifiedStatementNodeQuery(proofStepNode),
-          subproof = Subproof.fromSubproofNode(subproofNode, fileContext),
-          qualifiedStatement = QualifiedStatement.fromQualifiedStatementNode(qualifiedStatementNode, fileContext),
-          unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          proofStep = new ProofStep(subproof, qualifiedStatement, unqualifiedStatement);
-
-    return proofStep;
-  }
-
-  static fromUnqualifiedStatement(unqualifiedStatement) {
-    const subproof = null,
-          qualifiedStatement = null,
-          proofStep = new ProofStep(subproof, qualifiedStatement, unqualifiedStatement);
-
-    return proofStep;
-  }
-}
-
-Object.assign(shim, {
-  ProofStep
-});
-
-export default ProofStep;

package/src/shim.js

@@ -1,5 +0,0 @@
-"use strict"
-
-const shim = {};
-
-export default shim;

package/src/statement/qualified.js

@@ -1,133 +0,0 @@
-"use strict";
-
-import shim from "../shim";
-import Reference from "../reference";
-import unifyMixins from "../mixins/statement/qualified/unify";
-import LocalContext from "../context/local";
-
-import { trim } from "../utilities/string";
-import { nodeQuery } from "../utilities/query";
-import { assignAssignments } from "../utilities/assignments";
-
-const statementNodeQuery = nodeQuery("/qualifiedStatement/statement");
-
-class QualifiedStatement {
-  constructor(string, statement, reference) {
-    this.string = string;
-    this.statement = statement;
-    this.reference = reference;
-  }
-
-  getString() {
-    return this.string;
-  }
-
-  getStatement() {
-    return this.statement;
-  }
-
-  getReference() {
-    return this.reference;
-  }
-
-  getMetavariableNode() { return this.reference.getMetavariableNode(); }
-
-  unify(substitutions, context) {
-    let unified;
-
-    const qualifiedStatementString = this.string; ///
-
-    context.trace(`Unifying the '${qualifiedStatementString}' qualified statement...`);
-
-    unified = unifyMixins.some((unifyMixin) => {
-      const qualifiedStatement = this,  ///
-            unified = unifyMixin(qualifiedStatement, substitutions, context);
-
-      return unified;
-    });
-
-    if (unified) {
-      context.debug(`...unified the '${qualifiedStatementString}' qualified statement.`);
-    }
-
-    return unified;
-  }
-
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
-    let statementUnified;
-
-    const statementString = statement.getString(),
-          unqualifiedStatementString = this.getString();  ///
-
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${unqualifiedStatementString}' qualified statement...`);
-
-    statementUnified = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
-
-    if (statementUnified) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${unqualifiedStatementString}' qualified statement.`);
-    }
-
-    return statementUnified;
-  }
-
-  verify(substitutions, assignments, stated, context) {
-    let verified;
-
-    const qualifiedStatementString = this.string; ///
-
-    if (this.statement !== null) {
-      context.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`);
-
-      const statementVerified = this.statement.verify(assignments, stated, context);
-
-      if (statementVerified) {
-        const unified = this.unify(substitutions, context);
-
-        if (unified) {
-          const assignmentsAssigned = assignAssignments(assignments, context);
-
-          verified = assignmentsAssigned; ///
-        }
-      }
-
-      if (verified) {
-        context.debug(`...verified the '${qualifiedStatementString}' qualified statement.`);
-      }
-    } else {
-      context.debug(`Cannot verify the '${qualifiedStatementString}' qualified statement because it is nonsense.`);
-    }
-
-    return verified;
-  }
-
-  static fromQualifiedStatementNode(qualifiedStatementNode, fileContext) {
-    let qualifiedStatement = null;
-
-    if (qualifiedStatementNode !== null) {
-      let string;
-
-      const { Statement } = shim,
-            statementNode = statementNodeQuery(qualifiedStatementNode),
-            referenceNode = referenceNodeQuery(qualifiedStatementNode),
-            localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext, ///
-            statement = Statement.fromStatementNode(statementNode, context),
-            reference = Reference.fromReferenceNode(referenceNode, context),
-            node = qualifiedStatementNode;  ///
-
-      string = fileContext.nodeAsString(node);
-
-      string = trim(string);  ///
-
-      qualifiedStatement = new QualifiedStatement(string, statement, reference);
-    }
-
-    return qualifiedStatement;
-  }
-}
-
-Object.assign(shim, {
-  QualifiedStatement
-});
-
-export default QualifiedStatement;