occam-verify-cli 1.0.913 → 1.0.920

package/src/element/topLevelAssertion/axiom.js

@@ -1,12 +1,13 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
+import { asynchronousUtilities } from "occam-languages";
 
 import TopLevelAssertion from "../topLevelAssertion";
 
 import { define } from "../../elements";
+import { join, reconcile } from "../../utilities/context";
 
-const { backwardsEvery } = arrayUtilities;
+const { asyncMatch } = asynchronousUtilities;
 
 export default define(class Axiom extends TopLevelAssertion {
   getAxiomNode() {
@@ -73,173 +74,146 @@ export default define(class Axiom extends TopLevelAssertion {
     return signatureVerifies;
   }
 
-  unifyStep(step, context) {
-    let stepUnifies = false;
+  unifySignature(signature, context) {
+    let signatureUnifies;
 
-    context = step.getContext();
+    const axiomString = this.getString(), ///
+          signatureString = signature.getString();
 
-    const stepString = step.getString(),
-          axiomString = this.getString();
+    context.trace(`Unifying the '${signatureString}' signature with the '${axiomString}' axiom...`);
 
-    context.trace(`Unifying the '${stepString}' step with the '${axiomString}' axiom...`);
+    const specificSignature = signature;  ///
 
-    const unconditional = this.isUnconditional();
+    signature = this.getSignature();
 
-    if (!unconditional) {
-      context.trace(`Unable to unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`);
-    } else {
-      const statement = step.getStatement(),
-            statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, context);
+    const generalSignature = signature, ///
+          specificContext = context,  ///
+          generalContext = null;
 
-      if (statementUnifiesWithDeduction) {
-        stepUnifies = true;
-      }
-    }
+    signatureUnifies = generalSignature.unifySignature(specificSignature, generalContext, specificContext);
 
-    if (stepUnifies) {
-      context.debug(`...unified the '${stepString}' step with the '${axiomString}' axiom.`);
+    if (signatureUnifies) {
+      context.debug(`...unified the '${signatureString}' signature with the '${axiomString}' axiom.`);
     }
 
-    return stepUnifies;
+    return signatureUnifies;
   }
 
-  unifySubproof(subproof, context) {
-    let subproofUnifies = false;
-
-    const axiomString = this.getString(), ///
-          subproofString = subproof.getString();
-
-    context.trace(`Unifying the '${subproofString}' subproof with the '${axiomString}' axiom...`);
+  async unifyDeduction(deduction, context) {
+    let deductionUnifies;
 
-    const unconditional = this.isUnconditional();
+    await this.break(context);
 
-    if (unconditional) {
-      context.trace(`Unable to unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`);
-    } else {
-      const lastStep = subproof.getLastStep(),
-            lastStepUnifies = this.unifyLastStep(lastStep, context);
+    const axiomString = this.getString(), ///
+          generalDeduction = this.deduction,  ///
+          specificDeduction = deduction,  ///
+          generalDeductionString = generalDeduction.getString(),
+          specificDeductionString = specificDeduction.getString();
 
-      if (lastStepUnifies) {
-        const suppositions = subproof.getSuppositions(),
-              suppositionsUnify = this.unifySuppositions(suppositions, context);
+    context.trace(`Unifying the '${specificDeductionString}' deduction with the '${axiomString}' axiom's '${generalDeductionString}' deduction...`);
 
-        if (suppositionsUnify) {
-          subproofUnifies = true;
-        }
-      }
-    }
+    const specificDeductionContext = specificDeduction.getContext(),
+          generalDeductionContext = generalDeduction.getContext(),
+          specificContext = specificDeductionContext,  ///
+          generalContext = generalDeductionContext; ///
 
-    if (subproofUnifies) {
-      context.debug(`...unified the '${subproofString}' subproof with the '${axiomString}' axiom.`);
-    }
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        let statement;
 
-    return subproofUnifies;
-  }
+        statement = specificDeduction.getStatement();
 
-  unifyDeduction(deduction, generalContext, specificContext) {
-    let deductionUnifies;
+        const specificStatement = statement;  ///
 
-    const specificDeduction = deduction;  ///
+        statement = generalDeduction.getStatement();
 
-    deduction = this.getDeduction();
+        const generalStatement = statement, ///
+              statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
 
-    const generalDeduction = deduction; ///
+        if (statementUnifies) {
+          specificContext.commit();
 
-    deduction = specificDeduction;  ///
+          deductionUnifies = true;
+        }
+      }, specificContext);
+    }, specificContext, context);
 
-    deductionUnifies = generalDeduction.unifyDeduction(deduction, generalContext, specificContext);
+    if (deductionUnifies) {
+      context.debug(`...unified the '${specificDeductionString}' deduction with the '${axiomString}' axiom's '${generalDeductionString}' deduction.`);
+    }
 
     return deductionUnifies;
   }
 
-  unifySupposition(supposition, index, generalContext, specificContext) {
-    let suppositionUnifies;
+  async unifySupposition(supposition, index, context) {
+    let suppositionUnifies = false;
 
     const specificSupposition = supposition;  ///
 
     supposition = this.getSupposition(index);
 
-    const generalSupposition = supposition; ///
-
-    supposition = specificSupposition;  ///
+    const axiomString = this.getString(), ///
+          generalSupposition = supposition,  ///
+          generalSuppositionString = generalSupposition.getString(),
+          specificSuppositionString = specificSupposition.getString();
 
-    suppositionUnifies = generalSupposition.unifySupposition(supposition, generalContext, specificContext);
+    context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${axiomString}' axiom's '${generalSuppositionString}' supposition...`);
 
-    return suppositionUnifies;
-  }
+    const specificSuppositionContext = specificSupposition.getContext(),
+          generalSuppositionContext = generalSupposition.getContext(),
+          specificContext = specificSuppositionContext,  ///
+          generalContext = generalSuppositionContext; ///
 
-  unifySuppositions(suppositions, generalContext, specificContext) {
-    let suppositionsUnify = false;
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        let statement;
 
-    const specificSuppositions = suppositions;  ///
+        statement = specificSupposition.getStatement();
 
-    suppositions = this.getSuppositions();
+        const specificStatement = statement;  ///
 
-    const generalSuppositions = suppositions, ///
-          generalSuppositionsLength = generalSuppositions.length,
-          specificSuppositionsLength = specificSuppositions.length;
+        statement = generalSupposition.getStatement();
 
-    if (generalSuppositionsLength === specificSuppositionsLength) {
-      suppositions = specificSuppositions;  ///
+        const generalStatement = statement, ///
+              statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
 
-      suppositionsUnify = backwardsEvery(suppositions, (supposition, index) => {
-        const suppositionUnifies = this.unifySupposition(supposition, index, generalContext, specificContext);
+        if (statementUnifies) {
+          specificContext.commit();
 
-        if (suppositionUnifies) {
-          return true;
+          suppositionUnifies = true;
         }
-      });
-    }
-
-    return suppositionsUnify;
-  }
-
-  unifyLastStep(lastStep, context) {
-    let lastStepUnifies = false;
-
-    const axiomString = this.getString(), ///
-          lastStepString = lastStep.getString();
-
-    context.trace(`Unifying the '${lastStepString}' last step with the '${axiomString}' axiom...`);
-
-    const statement = lastStep.getStatement(),
-          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, context);
+      }, specificContext);
+    }, specificContext, context);
 
-    if (statementUnifiesWithDeduction) {
-      lastStepUnifies = true;
+    if (suppositionUnifies) {
+      context.debug(`...unified the '${specificSuppositionString}' supposition with the '${axiomString}' axiom's '${generalSuppositionString}' supposition...`);
     }
 
-    if (lastStepUnifies) {
-      context.debug(`...unified the '${lastStepString}' last step with the '${axiomString}' axiom.`);
-    }
-
-    return lastStepUnifies;
+    return suppositionUnifies;
   }
 
-  unifySignature(signature, context) {
-    let signatureUnifies;
-
-    const axiomString = this.getString(), ///
-          signatureString = signature.getString();
-
-    context.trace(`Unifying the '${signatureString}' signature with the '${axiomString}' axiom...`);
+  async unifySuppositions(suppositions, context) {
+    let suppositionsUnify;
 
-    const specificSignature = signature;  ///
+    const specificSuppositions = suppositions;  ///
 
-    signature = this.getSignature();
+    suppositions = this.getSuppositions();
 
-    const generalSignature = signature; ///
+    const generalSuppositions = suppositions; ///
 
-    signatureUnifies = generalSignature.unifySignature(specificSignature, context);
+    suppositionsUnify = await asyncMatch(generalSuppositions, specificSuppositions, async (generalSupposition, specificSupposition, index) => {
+      const supposition = specificSupposition,  ///
+            suppositionUnifies = await this.unifySupposition(supposition, index, context);
 
-    if (signatureUnifies) {
-      context.debug(`...unified the '${signatureString}' signature with the '${axiomString}' axiom.`);
-    }
+      if (suppositionUnifies) {
+        return true;
+      }
+    });
 
-    return signatureUnifies;
+    return suppositionsUnify;
   }
 
-  unifyTopLevelAssertion(topLevelAssertion, context) {
+  async unifyTopLevelAssertion(topLevelAssertion, context) {
     let topLevelAssertionUnifies = false;
 
     const axiomString = this.getString(), ///
@@ -247,25 +221,15 @@ export default define(class Axiom extends TopLevelAssertion {
 
     context.trace(`Unifying the '${topLevelAssertionString}' top level assertion with the '${axiomString}' axiom...`);
 
-    const hypothesesCorrelate = topLevelAssertion.correlateHypotheses(context);
-
-    if (hypothesesCorrelate) {
-      const specificContext = context;  ///
-
-      context = this.getContext();
-
-      const generalContext = context; ///
-
-      context = specificContext;  ///
-
-      const deduction = topLevelAssertion.getDeduction(),
-            deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
+    const deduction = topLevelAssertion.getDeduction(),
+          deductionUnifies = await this.unifyDeduction(deduction, context);
 
-      if (deductionUnifies) {
-        const suppositions = topLevelAssertion.getSuppositions(),
-              suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
+    if (deductionUnifies) {
+      const suppositions = topLevelAssertion.getSuppositions(),
+            suppositionsUnify = await this.unifySuppositions(suppositions, context);
 
-        topLevelAssertionUnifies = suppositionsUnify; ///
+      if (suppositionsUnify) {
+        topLevelAssertionUnifies = true;
       }
     }
 

package/src/element/topLevelAssertion.js

@@ -16,7 +16,7 @@ import { labelsFromJSON,
          hypothesesToHypothesesJSON,
          suppositionsToSuppositionsJSON } from "../utilities/json";
 
-const { reverse, correlate } = arrayUtilities,
+const { reverse } = arrayUtilities,
       { asyncExtract, asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
 
 export default class TopLevelAssertion extends Element {
@@ -91,35 +91,6 @@ export default class TopLevelAssertion extends Element {
     return metavariableNodeMatches;
   }
 
-  correlateHypotheses(context) {
-    let correlatesToHypotheses;
-
-    const hypothetical = this.isHypothetical();
-
-    if (hypothetical) {
-      const proofAssertions = context.getProofAssertions(),
-            topLevelAssertionString = this.getString();  ///
-
-      context.trace(`Correlating the hypotheses of the '${topLevelAssertionString}' top level assertion...`);
-
-      correlatesToHypotheses = correlate(this.hypotheses, proofAssertions, (hypothesis, proofAssertion) => {
-        const hypothesesComparesToStep = hypothesis.compareProofAssertion(proofAssertion, context);
-
-        if (hypothesesComparesToStep) {
-          return true;
-        }
-      });
-
-      if (correlatesToHypotheses) {
-        context.debug(`...correlated the hypotheses of the '${topLevelAssertionString}' top level assertion.`);
-      }
-    } else {
-      correlatesToHypotheses = true
-    }
-
-    return correlatesToHypotheses;
-  }
-
   async verify(context) {
     let verifies = false;
 
@@ -285,19 +256,18 @@ export default class TopLevelAssertion extends Element {
     await this.break(context);
 
     const stepString = step.getString(),
-          deductionString = this.deduction.getString(),
           topLevelAssertionString = this.getString(); ///
 
-    context.trace(`Unifying the '${stepString}' step with the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction...`);
+    context.trace(`Unifying the '${stepString}' step with the '${topLevelAssertionString}' top level assertion's deduction...`);
 
-    const stepUnifies = await this.deduction.unifyStep(step, context);
+    const stepUnifies = this.deduction.unifyStep(step, context);
 
     if (stepUnifies) {
       stepUnifiesWithDeduction = true;
     }
 
     if (stepUnifiesWithDeduction) {
-      context.debug(`...unified the '${stepString}' step with the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction.`);
+      context.debug(`...unified the '${stepString}' step with the '${topLevelAssertionString}' top level assertion's deduction.`);
     }
 
     return stepUnifiesWithDeduction;
@@ -306,20 +276,16 @@ export default class TopLevelAssertion extends Element {
   async unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context) {
     let stepAndSubproofOrProofAssertionsUnify = false;
 
-    const correlatesToHypotheses = this.correlateHypotheses(context);
-
-    if (correlatesToHypotheses) {
-      const stepUnifiesWithDeduction = await this.unifyStepWithDeduction(step, context);
+    const stepUnifiesWithDeduction = await this.unifyStepWithDeduction(step, context);
 
-      if (stepUnifiesWithDeduction) {
-        const subproofOrProofAssertionsUnifiesWithSuppositions = await this.unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, context);
+    if (stepUnifiesWithDeduction) {
+      const subproofOrProofAssertionsUnifiesWithSuppositions = await this.unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, context);
 
-        if (subproofOrProofAssertionsUnifiesWithSuppositions) {
-          const derivedSubstitutionsResolved = context.areDerivedSubstitutionsResolved();
+      if (subproofOrProofAssertionsUnifiesWithSuppositions) {
+        const derivedSubstitutionsResolved = context.areDerivedSubstitutionsResolved();
 
-          if (derivedSubstitutionsResolved) {
-            stepAndSubproofOrProofAssertionsUnify = true;
-          }
+        if (derivedSubstitutionsResolved) {
+          stepAndSubproofOrProofAssertionsUnify = true;
         }
       }
     }

package/src/node/proofAssertion/step.js

@@ -29,16 +29,16 @@ export default class StepNode extends ProofAssertionNode {
     return referenceNode;
   }
 
-  getSatisfiedAssertionNode() {
-    let satisfiedAssertionNode =  null;
+  getSignatureAssertionNode() {
+    let signatureAssertionNode =  null;
 
     const qualificationNode = this.getQualificationNode();
 
     if (qualificationNode !== null) {
-      satisfiedAssertionNode = qualificationNode.getSatisfiedAssertionNode();
+      signatureAssertionNode = qualificationNode.getSignatureAssertionNode();
     }
 
-    return satisfiedAssertionNode;
+    return signatureAssertionNode;
   }
 
   getQualificationNode() {

package/src/node/qualification.js

@@ -12,11 +12,11 @@ export default class QualificationNode extends NonTerminalNode {
     return referenceNode;
   }
 
-  getSatisfiedAssertionNode() {
+  getSignatureAssertionNode() {
     const ruleName = SIGNATURE_ASSERTION_RULE_NAME,
-          satisfiedAssertionNode = this.getNodeByRuleName(ruleName);
+          signatureAssertionNode = this.getNodeByRuleName(ruleName);
 
-    return satisfiedAssertionNode;
+    return signatureAssertionNode;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(QualificationNode, ruleName, childNodes, opacity, precedence); }

package/src/node/statement.js

@@ -135,11 +135,11 @@ export default class StatementNode extends NonTerminalNode {
     return containedAssertionNode;
   }
 
-  getSatisfiedAssertionNode() {
+  getSignatureAssertionNode() {
     const ruleName = SIGNATURE_ASSERTION_RULE_NAME,
-          satisfiedAssertionNode = this.getNodeByRuleName(ruleName);
+          signatureAssertionNode = this.getNodeByRuleName(ruleName);
 
-    return satisfiedAssertionNode;
+    return signatureAssertionNode;
   }
 
   getSingularMetavariableNode() {

package/src/process/unify.js

@@ -13,13 +13,14 @@ const typeNodeQuery = nodeQuery("/type"),
       termNodeQuery = nodeQuery("/term"),
       frameNodeQuery = nodeQuery("/frame"),
       metaTypeNodeQuery = nodeQuery("/metaType"),
+      signatureNodeQuery = nodeQuery("/signature"),
       statementNodeQuery = nodeQuery("/statement"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       assumptionMetavariableNodeQuery = nodeQuery("/assumption/metavariable!");
 
-class StatementPass extends ZipPassBase {
+class MetaLevelPass extends ZipPassBase {
   static maps = [
     {
       generalNodeQuery: assumptionMetavariableNodeQuery,
@@ -141,6 +142,30 @@ class StatementPass extends ZipPassBase {
           success = true;
         }
 
+        return success;
+      }
+    },
+    {
+      generalNodeQuery: signatureNodeQuery,
+      specificNodeQuery: signatureNodeQuery,
+      run: (generalSignatureNode, specificSignatureNode, generalContext, specificContext) => {
+        let success = false;
+
+         let context;
+
+        context = generalContext; ///
+
+        const generalSignature = context.findSignatureBySignatureNode(generalSignatureNode);
+
+        context = specificContext;  ///
+
+        const specificSignature = context.findSignatureBySignatureNode(specificSignatureNode),
+              signatureUnifies = generalSignature.unifySignature(specificSignature, generalContext, specificContext);
+
+        if (signatureUnifies) {
+          success = true;
+        }
+
         return success;
       }
     }
@@ -434,7 +459,7 @@ class IntrinsicMetavariablePass extends ZipPass {
   ];
 }
 
-const statementPass = new StatementPass(),
+const metaLevelPass = new MetaLevelPass(),
       combinatorPass = new CombinatorPass(),
       constructorPass = new ConstructorPass(),
       metavariablePass = new MetavariablePass(),
@@ -449,7 +474,7 @@ export function unifyStatement(generalStatement, specificStatement, generalConte
         specificStatementNode = specificStatement.getNode(),
         generalNode = generalStatementNode, ///
         specificNode = specificStatementNode,  ///
-        success = statementPass.run(generalNode, specificNode, generalContext, specificContext);
+        success = metaLevelPass.run(generalNode, specificNode, generalContext, specificContext);
 
   if (success) {
     statementUnifies = true;

package/src/utilities/context.js

@@ -16,6 +16,12 @@ import NominalFileContext from "../context/file/nominal";
 import { mnemicContextFromJSON, mnemicContextsFromJSON, mnemicContextToMnemicContextJSON, mnemicContextsToMnemicContextsJSON } from "../utilities/json";
 
 export function join(innerFunction, ...contexts) {
+  contexts = contexts.filter((context) => {
+    if (context !== null) {
+      return true;
+    }
+  });
+
   const synopticContext = SynopticContext.fromContexts(contexts),
         context = synopticContext;  ///
 

package/src/utilities/element.js

@@ -1556,7 +1556,7 @@ export function termFromPropertyAssertionNode(propertyAssertionNode, context) {
 export function signatureAssertionFromStepNode(stepNode, context) {
   let signatureAssertion = null;
 
-  const signatureAssertionNode = stepNode.getSatisfiedAssertionNode();
+  const signatureAssertionNode = stepNode.getSignatureAssertionNode();
 
   if (signatureAssertionNode !== null) {
     signatureAssertion = signatureAssertionFromSignatureAssertionNode(signatureAssertionNode, context);
@@ -1841,7 +1841,7 @@ export function containedAssertionFromStatementNode(statementNode, context) {0
 export function signatureAssertionFromStatementNode(statementNode, context) {
   let signatureAssertion = null;
 
-  const signatureAssertionNode = statementNode.getSatisfiedAssertionNode();
+  const signatureAssertionNode = statementNode.getSignatureAssertionNode();
 
   if (signatureAssertionNode !== null) {
     signatureAssertion = signatureAssertionFromSignatureAssertionNode(signatureAssertionNode, context);

package/src/utilities/equivalences.js

@@ -20,18 +20,6 @@ export function mergeEquivalences(equivalencesA, equivalencesB, context) {
   return equivalencesA;
 }
 
-export function findEquivalenceByTerm(equivalences, term) {
-  const equivalence = equivalences.find((equivalence) => {
-    const equivalenceEqualToTerm = equivalence.isEqualTo(term);
-
-    if (equivalenceEqualToTerm) {
-      return true;
-    }
-  }) || null;
-
-  return equivalence;
-}
-
 export function equivalencesFromEquality(equality, context) {
   const { Equivalence } = elements,
         eaulivalence = Equivalence.fromEquality(equality, context),