occam-verify-cli 1.0.913 → 1.0.919

package/src/utilities/unification.js

@@ -1,21 +1,16 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import elements from "../elements";
 
 import { descend } from "./context";
 
-const { backwardsSome } = arrayUtilities;
-
 async function unifyStepWithRule(step, context) {
   let stepUnifiesWithRule = false;
 
-  const qualified = step.isQualified();
+  const reference = step.getReference();
 
-  if (qualified) {
-    const reference = step.getReference(),
-          rule = context.findRuleByReference(reference);
+  if (reference !== null) {
+    const rule = context.findRuleByReference(reference);
 
     if (rule !== null) {
       const stepString = step.getString(),
@@ -42,11 +37,10 @@ async function unifyStepWithRule(step, context) {
 async function unifyStepWithReference(step, context) {
   let stepUnifiesWithReference = false;
 
-  const qualified = step.isQualified();
+  const reference = step.getReference();
 
-  if (qualified) {
-    const reference = step.getReference(),
-          stepString = step.getString(),
+  if (reference !== null) {
+    const stepString = step.getString(),
           referenceString = reference.getString();
 
     context.trace(`Unifying the '${stepString}' step with the '${referenceString}' reference...`);
@@ -83,79 +77,13 @@ async function unifyStepWithReference(step, context) {
   return stepUnifiesWithReference;
 }
 
-async function unifyStepAsSignatureAssertion(step, context) {
-  let stepUnifiesAsSignatureAssertion = false;
-
-  const { SignatureAssertion } = elements;
-
-  const signatureAssertion = SignatureAssertion.fromStep(step, context);
-
-  if (signatureAssertion !== null) {
-    const stepString = step.getString();
-
-    context.trace(`Unifying the '${stepString}' step as a signature assertion...`);
-
-    descend((context) => {
-      signatureAssertion.verifySignature(context);
-    }, context);
-
-    const unqualified = step.isUnqualified();
-
-    if (unqualified) {
-      const subproofOrProofAssertions = context.getSubproofOrProofAssertions();
-
-      stepUnifiesAsSignatureAssertion = backwardsSome(subproofOrProofAssertions, (stepsOrSubproof) => {
-        const stepOrSubProofUnifiesWIthSignatureAssertion = stepsOrSubproof.unifyWithSignatureAssertion(signatureAssertion, context);
-
-        if (stepOrSubProofUnifiesWIthSignatureAssertion) {
-          return true;
-        }
-      });
-    } else {
-      const reference = signatureAssertion.getReference(),
-            topLevelAssertion = context.findTopLevelAssertionByReference(reference);
-
-      if (topLevelAssertion !== null) {
-        const axiom = context.findAxiomByReference(reference);
-
-        if (axiom !== null) {
-          const satisfiable = axiom.isSatisfiable();
-
-          if (satisfiable) {
-            const topLevelAssertionUnifies = axiom.unifyTopLevelAssertion(topLevelAssertion, context);
-
-            if (topLevelAssertionUnifies) {
-              const substitutionsCorrelates = signatureAssertion.correlateSubstitutions(substitutions, context);
-
-              if (substitutionsCorrelates) {
-                stepUnifiesAsSignatureAssertion = true;
-              }
-            }
-          } else {
-            const axiomString = axiom.getString();
-
-            context.debug(`Unable to unify with the '${axiomString}' because it is not satisfiable.`)
-          }
-        }
-      }
-    }
-
-    if (stepUnifiesAsSignatureAssertion) {
-      context.debug(`...unified the '${stepString}' step as a signature assertion.`);
-    }
-  }
-
-  return stepUnifiesAsSignatureAssertion;
-}
-
 async function unifyStepWithTopLevelAssertion(step, context) {
   let stepUnifiesWithTopLevelAssertion = false;
 
-  const qualified = step.isQualified();
+  const reference = step.getReference();
 
-  if (qualified) {
-    const reference = step.getReference(),
-          topLevelAssertion = context.findTopLevelAssertionByReference(reference);
+  if (reference !== null) {
+    const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
     if (topLevelAssertion !== null) {
       const stepString = step.getString(),
@@ -179,8 +107,34 @@ async function unifyStepWithTopLevelAssertion(step, context) {
   return stepUnifiesWithTopLevelAssertion;
 }
 
-async function unifyStepAsEquality(step, context) {
-  let stepUnifiesAEquality = false;
+async function unifyStepWithSignatureAssertion(step, context) {
+  let stepUnifiesWithSignatureAssertion = false;
+
+  const signatureAssertion = step.getSignatureAssertion();
+
+  if (signatureAssertion !== null) {
+    const stepString = step.getString(),
+          signatureAssertionString = signatureAssertion.getString();
+
+    context.trace(`Unifying the '${stepString}' step with the '${signatureAssertionString}' signature assertion...`);
+
+    const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
+          stepAndSubproofOrProofAssertionsUnify = await signatureAssertion.unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context);
+
+    if (stepAndSubproofOrProofAssertionsUnify) {
+      stepUnifiesWithSignatureAssertion = true;
+    }
+
+    if (stepUnifiesWithSignatureAssertion) {
+      context.debug(`...unified the '${stepString}' step with the '${signatureAssertionString}' signature assertion.`);
+    }
+  }
+
+  return stepUnifiesWithSignatureAssertion;
+}
+
+async function unifyStepAsUnqualifiedEquality(step, context) {
+  let stepUnifiesAUnqualifiedEquality = false;
 
   const unqualified = step.isUnqualified();
 
@@ -192,25 +146,21 @@ async function unifyStepAsEquality(step, context) {
     if (equality !== null) {
       const stepString = step.getString();
 
-      context.trace(`Unifying the '${stepString}' step as an equality...`);
+      context.trace(`Unifying the '${stepString}' step as an unqualified equality...`);
 
-      const equalityEqual = equality.isEqual(context);
+      stepUnifiesAUnqualifiedEquality = true;
 
-      if (equalityEqual) {
-        stepUnifiesAEquality = true;
-      }
-
-      if (stepUnifiesAEquality) {
-        context.debug(`...unified the '${stepString}' step as an equality.`);
+      if (stepUnifiesAUnqualifiedEquality) {
+        context.debug(`...unified the '${stepString}' step as an unqualified equality.`);
       }
     }
   }
 
-  return stepUnifiesAEquality;
+  return stepUnifiesAUnqualifiedEquality;
 }
 
-async function unifyStepAsJudgement(step, context) {
-  let stepUnifiesAsJudgement = false;
+async function unifyStepAsUNqualifiedJudgement(step, context) {
+  let stepUnifiesAsUnqualifiedJudgement = false;
 
   const unqualified = step.isUnqualified();
 
@@ -222,21 +172,21 @@ async function unifyStepAsJudgement(step, context) {
     if (judgement !== null) {
       const stepString = step.getString();
 
-      context.trace(`Unifying the '${stepString}' step as a judgement...`);
+      context.trace(`Unifying the '${stepString}' step as an unqualified judgement...`);
 
-      stepUnifiesAsJudgement = true;
+      stepUnifiesAsUnqualifiedJudgement = true;
 
-      if (stepUnifiesAsJudgement) {
-        context.debug(`...unified the '${stepString}' step as a judgement.`);
+      if (stepUnifiesAsUnqualifiedJudgement) {
+        context.debug(`...unified the '${stepString}' step as an unqualified judgement.`);
       }
     }
   }
 
-  return stepUnifiesAsJudgement;
+  return stepUnifiesAsUnqualifiedJudgement;
 }
 
-async function unifyStepAsTypeAssertion(step, context) {
-  let stepUnifiesAsTypeAssertion = false;
+async function unifyStepAsUnqualifiedTypeAssertion(step, context) {
+  let stepUnifiesAsUnqualifiedTypeAssertion = false;
 
   const unqualified = step.isUnqualified();
 
@@ -248,19 +198,21 @@ async function unifyStepAsTypeAssertion(step, context) {
     if (typeAssertion !== null) {
       const stepString = step.getString();
 
-      context.trace(`Unifying the '${stepString}' step as a type assertion...`);
+      context.trace(`Unifying the '${stepString}' step as an unqualified type assertion...`);
 
-      stepUnifiesAsTypeAssertion = true;
+      stepUnifiesAsUnqualifiedTypeAssertion = true;
 
-      context.debug(`...unified the '${stepString}' step as a type assertion.`);
+      if (stepUnifiesAsUnqualifiedTypeAssertion) {
+        context.debug(`...unified the '${stepString}' step as an unqualified type assertion.`);
+      }
     }
   }
 
-  return stepUnifiesAsTypeAssertion;
+  return stepUnifiesAsUnqualifiedTypeAssertion;
 }
 
-async function unifyStepAsPropertyAssertion(step, context) {
-  let stepUnifiesAsPropertyAssertion = false;
+async function unifyStepAsUnqualifiedPropertyAssertion(step, context) {
+  let stepUnifiesAsUnqualifiedPropertyAssertion = false;
 
   const unqualified = step.isUnqualified();
 
@@ -272,59 +224,78 @@ async function unifyStepAsPropertyAssertion(step, context) {
     if (propertyAssertion !== null) {
       const stepString = step.getString();
 
-      context.trace(`Unifying the '${stepString}' step as a property assertion...`);
+      context.trace(`Unifying the '${stepString}' step as an unqualified property assertion...`);
 
-      const term = propertyAssertion.getTerm(),
-            equivalence = context.findEquivalenceByTerm(term);
+      stepUnifiesAsUnqualifiedPropertyAssertion = true;
 
-      if (equivalence !== null) {
-        const propertyAssertionMatches = equivalence.someOtherTerm(term, (term) => {  ///
-          const propertyRelation = propertyAssertion.getPropertyRelation(),
-                comparesToTermAndPropertyRelation = context.compareTermAndPropertyRelation(term, propertyRelation);
+      if (stepUnifiesAsUnqualifiedPropertyAssertion) {
+        context.debug(`...unified the '${stepString}' step as an unqualified property assertion.`);
+      }
+    }
+  }
 
-          if (comparesToTermAndPropertyRelation) {
-            return true;
-          }
-        });
+  return stepUnifiesAsUnqualifiedPropertyAssertion;
+}
 
-        if (propertyAssertionMatches) {
-          stepUnifiesAsPropertyAssertion = true;
-        }
-      }
+async function unifyStepAsUnqualifiedSignatureAssertion(step, context) {
+  let stepUnifiesAsUnqualifiedSignatureAssertion = false;
 
-      if (stepUnifiesAsPropertyAssertion) {
-        context.debug(`...unified the '${stepString}' step as a property assertion.`);
+  const unqualified = step.isUnqualified();
+
+  if (unqualified) {
+    const { SignatureAssertion } = elements,
+          statement = step.getStatement(),
+          signatureAssertion = SignatureAssertion.fromStatement(statement, context);
+
+    if (signatureAssertion !== null) {
+      const stepString = step.getString();
+
+      context.trace(`Unifying the '${stepString}' step as a signature assertion...`);
+
+      stepUnifiesAsUnqualifiedSignatureAssertion = true;
+
+      if (stepUnifiesAsUnqualifiedSignatureAssertion) {
+        context.debug(`...unified the '${stepString}' step as a signature assertion.`);
       }
     }
   }
 
-  return stepUnifiesAsPropertyAssertion;
+  return stepUnifiesAsUnqualifiedSignatureAssertion;
 }
 
-async function unifyStepWithSignatureAssertion(step, context) {
-  let stepUnifiesWithSignatureAssertion = false;
+async function unifyStepAsSignatureAssertionWithReference(step, context) {
+  let stepUnifiesAsSignatureAssertionWithReference = false;
 
-  const signatureAssertion = step.getSignatureAssertion();
+  const reference = step.getReference();
 
-  if (signatureAssertion !== null) {
-    const stepString = step.getString(),
-          signatureAssertionString = signatureAssertion.getString();
+  if (reference !== null) {
+    const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
-    context.trace(`Unifying the '${stepString}' step with the '${signatureAssertionString}' signature assertion...`);
+    if (topLevelAssertion !== null) {
+      const statementNode = step.getStatementNode(),
+            signatureAssertionNode = statementNode.getSignatureAssertionNode();
 
-    const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
-          stepUnifies = signatureAssertion.unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context);
+      if (signatureAssertionNode !== null) {
+        const stepString = step.getString(),
+              referenceString = reference.getString(),
+              signatureAssertion = context.findAssertionByAssertionNode(signatureAssertionNode);
 
-    if (stepUnifies) {
-      stepUnifiesWithSignatureAssertion = true;
-    }
+        context.trace(`Unifying the '${stepString}' step as a signature assertion with the '${referenceString}' reference...`);
 
-    if (stepUnifiesWithSignatureAssertion) {
-      context.debug(`...unified the '${stepString}' step with the '${signatureAssertionString}' signature assertion.`);
+        const unifyTopLevelAssertion = await signatureAssertion.unifyTopLevelAssertion(topLevelAssertion, context);
+
+        if (unifyTopLevelAssertion) {
+          stepUnifiesAsSignatureAssertionWithReference = true;
+        }
+
+        if (stepUnifiesAsSignatureAssertionWithReference) {
+          context.debug(`...unified the '${stepString}' step as a signature assertion with the '${referenceString}' reference.`);
+        }
+      }
     }
   }
 
-  return stepUnifiesWithSignatureAssertion;
+  return stepUnifiesAsSignatureAssertionWithReference;
 }
 
 async function compareStepWithSubproofOrProofAssertions(step, context) {
@@ -355,12 +326,13 @@ async function compareStepWithSubproofOrProofAssertions(step, context) {
 export const unifySteps = [
   unifyStepWithRule,
   unifyStepWithReference,
-  unifyStepAsSignatureAssertion,
   unifyStepWithTopLevelAssertion,
-  unifyStepAsEquality,
-  unifyStepAsJudgement,
-  unifyStepAsTypeAssertion,
-  unifyStepAsPropertyAssertion,
   unifyStepWithSignatureAssertion,
+  unifyStepAsUnqualifiedEquality,
+  unifyStepAsUNqualifiedJudgement,
+  unifyStepAsUnqualifiedTypeAssertion,
+  unifyStepAsUnqualifiedPropertyAssertion,
+  unifyStepAsUnqualifiedSignatureAssertion,
+  unifyStepAsSignatureAssertionWithReference,
   compareStepWithSubproofOrProofAssertions
 ];