occam-verify-cli 1.0.913 → 1.0.919

package/src/element/topLevelAssertion/axiom.js

@@ -1,12 +1,9 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import TopLevelAssertion from "../topLevelAssertion";
 
 import { define } from "../../elements";
-
-const { backwardsEvery } = arrayUtilities;
+import supposition from "../proofAssertion/supposition";
 
 export default define(class Axiom extends TopLevelAssertion {
   getAxiomNode() {
@@ -73,149 +70,6 @@ export default define(class Axiom extends TopLevelAssertion {
     return signatureVerifies;
   }
 
-  unifyStep(step, context) {
-    let stepUnifies = false;
-
-    context = step.getContext();
-
-    const stepString = step.getString(),
-          axiomString = this.getString();
-
-    context.trace(`Unifying the '${stepString}' step with the '${axiomString}' axiom...`);
-
-    const unconditional = this.isUnconditional();
-
-    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);
-
-      if (statementUnifiesWithDeduction) {
-        stepUnifies = true;
-      }
-    }
-
-    if (stepUnifies) {
-      context.debug(`...unified the '${stepString}' step with the '${axiomString}' axiom.`);
-    }
-
-    return stepUnifies;
-  }
-
-  unifySubproof(subproof, context) {
-    let subproofUnifies = false;
-
-    const axiomString = this.getString(), ///
-          subproofString = subproof.getString();
-
-    context.trace(`Unifying the '${subproofString}' subproof with the '${axiomString}' axiom...`);
-
-    const unconditional = this.isUnconditional();
-
-    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);
-
-      if (lastStepUnifies) {
-        const suppositions = subproof.getSuppositions(),
-              suppositionsUnify = this.unifySuppositions(suppositions, context);
-
-        if (suppositionsUnify) {
-          subproofUnifies = true;
-        }
-      }
-    }
-
-    if (subproofUnifies) {
-      context.debug(`...unified the '${subproofString}' subproof with the '${axiomString}' axiom.`);
-    }
-
-    return subproofUnifies;
-  }
-
-  unifyDeduction(deduction, generalContext, specificContext) {
-    let deductionUnifies;
-
-    const specificDeduction = deduction;  ///
-
-    deduction = this.getDeduction();
-
-    const generalDeduction = deduction; ///
-
-    deduction = specificDeduction;  ///
-
-    deductionUnifies = generalDeduction.unifyDeduction(deduction, generalContext, specificContext);
-
-    return deductionUnifies;
-  }
-
-  unifySupposition(supposition, index, generalContext, specificContext) {
-    let suppositionUnifies;
-
-    const specificSupposition = supposition;  ///
-
-    supposition = this.getSupposition(index);
-
-    const generalSupposition = supposition; ///
-
-    supposition = specificSupposition;  ///
-
-    suppositionUnifies = generalSupposition.unifySupposition(supposition, generalContext, specificContext);
-
-    return suppositionUnifies;
-  }
-
-  unifySuppositions(suppositions, generalContext, specificContext) {
-    let suppositionsUnify = false;
-
-    const specificSuppositions = suppositions;  ///
-
-    suppositions = this.getSuppositions();
-
-    const generalSuppositions = suppositions, ///
-          generalSuppositionsLength = generalSuppositions.length,
-          specificSuppositionsLength = specificSuppositions.length;
-
-    if (generalSuppositionsLength === specificSuppositionsLength) {
-      suppositions = specificSuppositions;  ///
-
-      suppositionsUnify = backwardsEvery(suppositions, (supposition, index) => {
-        const suppositionUnifies = this.unifySupposition(supposition, index, generalContext, specificContext);
-
-        if (suppositionUnifies) {
-          return 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);
-
-    if (statementUnifiesWithDeduction) {
-      lastStepUnifies = true;
-    }
-
-    if (lastStepUnifies) {
-      context.debug(`...unified the '${lastStepString}' last step with the '${axiomString}' axiom.`);
-    }
-
-    return lastStepUnifies;
-  }
-
   unifySignature(signature, context) {
     let signatureUnifies;
 
@@ -228,9 +82,11 @@ export default define(class Axiom extends TopLevelAssertion {
 
     signature = this.getSignature();
 
-    const generalSignature = signature; ///
+    const generalSignature = signature, ///
+          specificContext = context,  ///
+          generalContext = null;
 
-    signatureUnifies = generalSignature.unifySignature(specificSignature, context);
+    signatureUnifies = generalSignature.unifySignature(specificSignature, generalContext, specificContext);
 
     if (signatureUnifies) {
       context.debug(`...unified the '${signatureString}' signature with the '${axiomString}' axiom.`);
@@ -239,40 +95,40 @@ export default define(class Axiom extends TopLevelAssertion {
     return signatureUnifies;
   }
 
-  unifyTopLevelAssertion(topLevelAssertion, context) {
-    let topLevelAssertionUnifies = false;
+  async unifyDeduction(deduction, context) {
+    let deductionUnifies;
 
-    const axiomString = this.getString(), ///
-          topLevelAssertionString = topLevelAssertion.getString();
+    await this.break(context);
 
-    context.trace(`Unifying the '${topLevelAssertionString}' top level assertion with the '${axiomString}' axiom...`);
+    const asiomString = this.getString(), ///,
+          deductionString = deduction.getString();
 
-    const hypothesesCorrelate = topLevelAssertion.correlateHypotheses(context);
+    context.trace(`Unifying the '${deductionString}' deduction with the '${asiomString}' axiom's deduction...`);
 
-    if (hypothesesCorrelate) {
-      const specificContext = context;  ///
+    deductionUnifies = this.deduction.unifyDeduction(deduction, context);
 
-      context = this.getContext();
+    if (deductionUnifies) {
+      context.debug(`...unified the '${deductionString}' deduction with the '${asiomString}' axiom's deduction.`);
+    }
 
-      const generalContext = context; ///
+    return deductionUnifies;
+  }
 
-      context = specificContext;  ///
+  async unifyTopLevelAssertion(topLevelAssertion, context) {
+    let topLevelAssertionUnifies = false;
 
-      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;
       }
     }
 
-    if (topLevelAssertionUnifies) {
-      context.debug(`...unified the '${topLevelAssertionString}' top level assertion with the '${axiomString}' axiom.`);
-    }
-
     return topLevelAssertionUnifies;
   }
 

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),