occam-verify-cli 1.0.911 → 1.0.919

package/src/element/assertion/signature.js

@@ -3,9 +3,9 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { instantiate } from "../../utilities/context";
+import { join, reconcile, instantiate } from "../../utilities/context";
 import { instantiateSignatureAssertion } from "../../process/instantiate";
-import { signatureFromJSignatureAssertionNode, referenceFromJSignatureAssertionNode, signatureAssertionFromStatementNode } from "../../utilities/element";
+import { signatureFromSignatureAssertionNode, referenceFromSignatureAssertionNode, signatureAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class SignatureAssertion extends Assertion {
   constructor(context, string, node, lineIndex, signature, reference) {
@@ -30,10 +30,6 @@ export default define(class SignatureAssertion extends Assertion {
     return signatureAssertionNode;
   }
 
-  compareSubstitutions(substitutions, context) { return this.signature.compareSubstitutions(substitutions, context); }
-
-  correlateSubstitutions(substitutions, context) { return this.signature.correlateSubstitutions(substitutions, context); }
-
   validate(context) {
     let signatureAssertion = null;
 
@@ -118,7 +114,7 @@ export default define(class SignatureAssertion extends Assertion {
         const satisfiable = axiom.isSatisfiable();
 
         if (satisfiable) {
-          const signatureUnifies = axiom.unifySignature(this.signature, context);
+          const signatureUnifies = this.unifySignature(context);
 
           if (signatureUnifies) {
             this.reference = reference;
@@ -130,7 +126,6 @@ export default define(class SignatureAssertion extends Assertion {
 
           context.debug(`The '${axiomString}' axiom is not satisfiable.`);
         }
-
       } else {
         const referencdString = reference.getString();
 
@@ -145,46 +140,64 @@ export default define(class SignatureAssertion extends Assertion {
     return referenceVerifies;
   }
 
-  unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context) {
-    let stepAndSubproofOrProofAssertionsUnify = false;
+  unifySignature(context) {
+    let signatureUnifies;
+
+    const signatureAssertionString = this.getString();  ///
+
+    context.trace(`Unifying the '${signatureAssertionString}' signature assertion's signature...`);
 
-    const steptString = step.getString(),
-          signatureAssertionString = this.getString(); ///
+    const axiom = context.findAxiomByReference(this.reference);
 
-    context.trace(`Unifying the '${steptString}' step with the '${signatureAssertionString}' signature assertion...`);
+    context = this.signature.getContext();
+
+    reconcile((context) => {
+      signatureUnifies = axiom.unifySignature(this.signature, context);
+    }, context);
+
+    if (signatureUnifies) {
+      context.debug(`...unified the '${signatureAssertionString}' signature assertion's signature.`);
+    }
+
+    return signatureUnifies;
+  }
 
-    this.signature.validate(context);
+  async unifyTopLevelAssertion(topLevelAssertion, context) {
+    let topLevelAssertionUnifies;
 
     const axiom = context.findAxiomByReference(this.reference),
-          satisfiable = axiom.isSatisfiable();
+          signatureContext = this.signature.getContext(),
+          specificContext = signatureContext; ///
 
-    if (satisfiable) {
-      const axiomComparesToSignature = axiom.compareSignature(this.signature, context);
+    await join(async (specificContext) => {
+      const context = specificContext;  ///
 
-      if (axiomComparesToSignature) {
-        const substitutionsB = substitutions; ///
+      await reconcile(async (context) => {
+        axiom.unifySignature(this.signature, context);
 
-        stepAndSubproofOrProofAssertionsUnify = unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context);
+        topLevelAssertionUnifies = await axiom.unifyTopLevelAssertion(topLevelAssertion, context);
+      }, context);
+    }, specificContext, context);
 
-        if (stepAndSubproofOrProofAssertionsUnify) {
-          const substitutionsA = substitutions, ///
-                substitutionsCorrelate = substitutionsA.correlateSubstitutions(substitutionsB);
+    return topLevelAssertionUnifies;
+  }
 
-          if (!substitutionsCorrelate) {
-            const substitutionsAString = substitutionsA.asString(),
-                  substitutionsBString = substitutionsB.asString();
+  async unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context) {
+    let stepAndSubproofOrProofAssertionsUnify;
 
-            context.trace(`THe signature's ${substitutionsBString} substitutions do not correlate with the unification's ${substitutionsAString} substitutions.`);
+    const axiom = context.findAxiomByReference(this.reference),
+          signatureContext = this.signature.getContext(),
+          specificContext = signatureContext; ///
 
-            stepAndSubproofOrProofAssertionsUnify = false;
-          }
-        }
-      }
-    }
+    await join(async (specificContext) => {
+      const context = specificContext;  ///
 
-    if (stepAndSubproofOrProofAssertionsUnify) {
-      context.debug(`...unified the '${steptString}' step with the '${signatureAssertionString}' signature assertion.`);
-    }
+      await reconcile(async (context) => {
+        axiom.unifySignature(this.signature, context);
+
+        stepAndSubproofOrProofAssertionsUnify = await axiom.unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context);
+      }, context);
+    }, specificContext, context);
 
     return stepAndSubproofOrProofAssertionsUnify;
   }
@@ -201,8 +214,8 @@ export default define(class SignatureAssertion extends Assertion {
         const { string, lineIndex } = json,
               definedAssertionNode = instantiateSignatureAssertion(string, context),
               node = definedAssertionNode,  ///
-              signature = signatureFromJSignatureAssertionNode(definedAssertionNode, context),
-              reference = referenceFromJSignatureAssertionNode(definedAssertionNode, context);
+              signature = signatureFromSignatureAssertionNode(definedAssertionNode, context),
+              reference = referenceFromSignatureAssertionNode(definedAssertionNode, context);
 
         context = null;
 

package/src/element/deduction.js

@@ -4,7 +4,7 @@ import { Element } from "occam-languages";
 
 import { define } from "../elements";
 import { instantiateDeduction } from "../process/instantiate";
-import { declare, attempt, descend, serialise, unserialise, instantiate } from "../utilities/context";
+import { join, declare, attempt, descend, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Deduction extends Element {
   constructor(context, string, node, lineIndex, statement) {
@@ -130,23 +130,33 @@ export default define(class Deduction extends Element {
     return stepUnifies;
   }
 
-  unifyDeduction(deduction, substitutions, generalContext, specificContext) {
+  unifyDeduction(deduction, context) {
     let deductionUnifies = false;
 
-    const context = specificContext,  ///
-          generalDeduction = this,  ///
+    const generalDeduction = this,  ///
           specificDeduction = deduction,  ///
           generalDeductionString = generalDeduction.getString(),
           specificDeductionString = specificDeduction.getString();
 
     context.trace(`Unifying the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction...`);
 
-    const statement = specificDeduction.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+    const specificDeductionContext = specificDeduction.getContext(),
+          generalDeductionContext = generalDeduction.getContext(),
+          specificContext = specificDeductionContext,  ///
+          generalContext = generalDeductionContext; ///
 
-    if (statementUnifies) {
-      deductionUnifies = true;
-    }
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const statement = specificDeduction.getStatement(),
+              statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
+
+        if (statementUnifies) {
+          specificContext.commit();
+
+          deductionUnifies = true;
+        }
+      }, specificContext);
+    }, specificContext, context);
 
     if (deductionUnifies) {
       context.debug(`...unified the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction.`);

package/src/element/proofAssertion/step.js

@@ -50,7 +50,7 @@ export default define(class Step extends ProofAssertion {
   }
 
   isQualified() {
-    const qualified = (this.reference !== null);
+    const qualified = ((this.reference !== null) || (this.signatureAssertion !== null));
 
     return qualified;
   }
@@ -164,29 +164,6 @@ export default define(class Step extends ProofAssertion {
     return validates;
   }
 
-  validateReference(context) {
-    let referenceValidates = true;  ///
-
-    if (this.reference !== null) {
-      const stepString = this.getString(),  ///
-            referenceString = this.reference.getString();
-
-      context.trace(`Validating the '${stepString}' step's '${referenceString}' reference... `);
-
-      const reference = this.reference.validate(context);
-
-      if (reference === null) {
-        referenceValidates = false;
-      }
-
-      if (referenceValidates) {
-        context.debug(`...validated the '${stepString}' step's '${referenceString}' reference. `);
-      }
-    }
-
-    return referenceValidates;
-  }
-
   validateStatement(context) {
     let statementValidates = false;
 
@@ -211,8 +188,35 @@ export default define(class Step extends ProofAssertion {
     return statementValidates;
   }
 
+  validateReference(context) {
+    let referenceValidates = false;
+
+    if (this.reference !== null) {
+      const stepString = this.getString(),  ///
+            referenceString = this.reference.getString();
+
+      context.trace(`Validating the '${stepString}' step's '${referenceString}' reference... `);
+
+      const reference = this.reference.validate(context);
+
+      if (reference !== null) {
+        this.reference = reference;
+
+        referenceValidates = true;
+      }
+
+      if (referenceValidates) {
+        context.debug(`...validated the '${stepString}' step's '${referenceString}' reference. `);
+      }
+    } else {
+      referenceValidates = true;
+    }
+
+    return referenceValidates;
+  }
+
   validateSignatureAssertion(context) {
-    let signatureAssertionValidates = true;  ///
+    let signatureAssertionValidates = false;
 
     if (this.signatureAssertion !== null) {
       const stepString = this.getString(),  ///
@@ -222,13 +226,17 @@ export default define(class Step extends ProofAssertion {
 
       const signatureAssertion = this.signatureAssertion.validate(context);
 
-      if (signatureAssertion === null) {
-        signatureAssertionValidates = false;
+      if (signatureAssertion !== null) {
+        this.signatureAssertion = signatureAssertion;
+
+        signatureAssertionValidates = true;
       }
 
       if (signatureAssertionValidates) {
-        context.debug(`...validating the '${stepString}' step's '${signatureAssertionString}' signature assertion. `);
+        context.debug(`...validated the '${stepString}' step's '${signatureAssertionString}' signature assertion. `);
       }
+    } else {
+      signatureAssertionValidates = true;
     }
 
     return signatureAssertionValidates;
@@ -264,36 +272,5 @@ export default define(class Step extends ProofAssertion {
     return unifies;
   }
 
-  unifyWithSignatureAssertion(signatureAssertion, context) {
-    let unifiesWithSignatureAssertion = false;
-
-    const stepString = this.getString(), ///
-          signatureAssertionString = signatureAssertion.getString();
-
-    context.trace(`Unifying the '${stepString}' step with the '${signatureAssertionString}' signature assertion...`);
-
-    const reference = signatureAssertion.getReference(),
-          axiom = context.findAxiomByReference(reference);
-
-    if (axiom !== null) {
-      const step = this,  ///
-            stepUnifies = axiom.unifyStep(step, context);
-
-      if (stepUnifies) {
-        const substitutionsCompare = signatureAssertion.compareSubstitutions(context);
-
-        if (substitutionsCompare) {
-          unifiesWithSignatureAssertion = true;
-        }
-      }
-    }
-
-    if (unifiesWithSignatureAssertion) {
-      context.debug(`...unified the '${stepString}' step with the '${signatureAssertionString}' signature assertion.`);
-    }
-
-    return unifiesWithSignatureAssertion;
-  }
-
   static name = "Step";
 });

package/src/element/signature.js

@@ -5,10 +5,10 @@ import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
 import { instantiateSignature } from "../process/instantiate";
-import { termsFromSignatureNode } from "../utilities/element";
-import { attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
+import { signatureFromSignatureNode } from "../utilities/element";
+import { join, ablate, attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
 
-const { match, compare, correlate } = arrayUtilities;
+const { match } = arrayUtilities;
 
 export default define(class Signature extends Element {
   constructor(context, string, node, lineIndex, terms) {
@@ -41,6 +41,22 @@ export default define(class Signature extends Element {
     return term;
   }
 
+  isEqualTo(signature) {
+    const signatureNode = signature.getNode(),
+          signatureNodeMatches = this.matchSignatureNode(signatureNode),
+          equalTo = signatureNodeMatches;  ///
+
+    return equalTo;
+  }
+
+  matchSignatureNode(signatureNode) {
+    const node = signatureNode, ///
+          nodeMatches = this.matchNode(node),
+          signatureNodeMatches = nodeMatches; ///
+
+    return signatureNodeMatches;
+  }
+
   findValidSignature(context) {
     const signatureNode = this.getSignatureNode(),
           signature = context.findSignatureBySignatureNode(signatureNode),
@@ -157,48 +173,52 @@ export default define(class Signature extends Element {
     return termsValidate
   }
 
-  unifySignature(signature, context) {
-    let signatureUnifies = false;
+  unifySignature(signature, generalContext, specificContext) {
+    let signatureUnifies;
 
-    const generalSignature = this,
+    const context = specificContext,  ///
+          generalSignature = this,
           specificSignature = signature,  ///
           generalSignatureString = generalSignature.getString(),
           specificSignatureString = specificSignature.getString();
 
     context.trace(`Unifying the '${specificSignatureString}' signature with the '${generalSignatureString}' signature...`);
 
-    context = specificSignature.getContext();
-
-    const specificContext = context;  ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = specificContext;  ///
-
-    reconcile((specificContext) => {
-      const generalSignatureTerms = generalSignature.getTerms(),
-            specificSignatureTerms = specificSignature.getTerms(),
-            generalTerms = generalSignatureTerms,  ///
-            specificTerms = specificSignatureTerms; ///
-
-      signatureUnifies = match(generalTerms, specificTerms, (generalTerm, specificTerm) => {
-        let termUnifies;
-
-        reconcile((specificContext) => {
-          termUnifies = generalTerm.unifyTerm(specificTerm, generalContext, specificContext);
+    const generalSignatureTerms = generalSignature.getTerms(),
+          specificSignatureTerms = specificSignature.getTerms(),
+          generalSignatureContext = generalSignature.getContext(),
+          specificSignatureContext = specificSignature.getContext(),
+          generalTerms = generalSignatureTerms,  ///
+          specificTerms = specificSignatureTerms, ///
+          generalContexts = [
+            generalSignatureContext,
+            generalContext
+          ],
+          specificContexts = [
+            specificSignatureContext,
+            specificContext
+          ];
+
+    join((generalContext) => {
+      join((specificContext) => {
+        signatureUnifies = match(generalTerms, specificTerms, (generalTerm, specificTerm) => {
+          let termUnifies;
+
+          reconcile((specificContext) => {
+            termUnifies = generalTerm.unifyTerm(specificTerm, generalContext, specificContext);
+
+            if (termUnifies) {
+              specificContext.commit();
+            }
+          }, specificContext);
 
           if (termUnifies) {
-            specificContext.commit();
+            return true;
           }
-        }, specificContext);
+        });
+      }, ...specificContexts);
+    }, ...generalContexts);
 
-        if (termUnifies) {
-          return true;
-        }
-      });
-    }, specificContext);
 
     if (signatureUnifies) {
       context.debug(`...unified the '${specificSignatureString}' signature with the '${generalSignatureString}' signature.`);
@@ -207,64 +227,6 @@ export default define(class Signature extends Element {
     return signatureUnifies;
   }
 
-  compareSubstitutions(substitutions, context) {
-    let substitutionsCompares = false;
-
-    const signatureString = this.getString(),  ///
-          substitutionsString = substitutions.asString();
-
-    context.trace(`Comparing the '${substitutionsString}' substitutions against the '${signatureString}' signature...`);
-
-    const array = substitutions.getArray(),
-          compares = compare(this.terms, array, (term, substitution) => {
-            const substitutionTerm = substitution.getTerm(),
-                  substitutionTermEqualToTerm = substitutionTerm.isEqualTo(term);
-
-            if (substitutionTermEqualToTerm) {
-              return true;
-            }
-          });
-
-    if (compares) {
-      substitutionsCompares = true;
-    }
-
-    if (substitutionsCompares) {
-      context.debug(`...compared the '${substitutionsString}' substitutions against the '${signatureString}' signature.`);
-    }
-
-    return substitutionsCompares;
-  }
-
-  correlateSubstitutions(substitutions, context) {
-    let substitutionsCorrelates = false;
-
-    const signatureString = this.getString(),  ///
-          substitutionsString = substitutions.asString();
-
-    context.trace(`Correlating the '${substitutionsString}' substitutions against the '${signatureString}' signature...`);
-
-    const array = substitutions.getArray(),
-          correlates = correlate(this.terms, array, (term, substitution) => {
-            const substitutionTerm = substitution.getTerm(),
-                  substitutionTermEqualToTerm = substitutionTerm.isEqualTo(term);
-
-            if (substitutionTermEqualToTerm) {
-              return true;
-            }
-          });
-
-    if (correlates) {
-      substitutionsCorrelates = true;
-    }
-
-    if (substitutionsCorrelates) {
-      context.debug(`...correlated the '${substitutionsString}' substitutions against the '${signatureString}' signature.`);
-    }
-
-    return substitutionsCorrelates;
-  }
-
   static name = "Signature";
 
   toJSON() {
@@ -299,4 +261,30 @@ export default define(class Signature extends Element {
 
     return signature;
   }
+
+  static fromSignatureString(signatureString, context) {
+    let signature;
+
+    ablate((context) => {
+      instantiate((context) => {
+        const string = signatureString,  ///
+              signatureNode = instantiateSignature(string, context);
+
+        signature = signatureFromSignatureNode(signatureNode, context);
+      }, context);
+    }, context);
+
+    return signature;
+  }
 });
+
+function termsFromSignatureNode(signatureNode, context) {
+  const termNodes = signatureNode.getTermNodes(),
+        terms = termNodes.map((termNode) => {
+          const term = context.findTermByTermNode(termNode);
+
+          return term;
+        });
+
+  return terms;
+}

package/src/element/subproof.js

@@ -112,40 +112,5 @@ export default define(class Subproof extends Element {
     return subDerivationVerifies;
   }
 
-  unifyWithSignatureAssertion(signatureAssertion, context) {
-    let unifiesWithSignatureAssertion = false;
-
-    const subproofString = this.getString(), ///
-          signatureAssertionString = signatureAssertion.getString();
-
-    context.trace(`Unifying the '${subproofString}' subproof with the '${signatureAssertionString}' signature assertion...`)
-
-    const reference = signatureAssertion.getReference(),
-          axiom = context.findAxiomByReference(reference);
-
-    if (axiom !== null) {
-      const axiomSatisfiable = axiom.isSatisfiable();
-
-      if (axiomSatisfiable) {
-        const subproof = this,  ///
-              statementUnifies = axiom.unifySubproof(subproof, context);
-
-        if (statementUnifies) {
-          const substitutionsCompare = signatureAssertion.compareSubstitutions(substitutions, context);
-
-          if (substitutionsCompare) {
-            unifiesWithSignatureAssertion = true;
-          }
-        }
-      }
-    }
-
-    if (unifiesWithSignatureAssertion) {
-      context.debug(`...unified the '${subproofString}' subproof with the '${signatureAssertionString}' signature assertion.`)
-    }
-
-    return unifiesWithSignatureAssertion;
-  }
-
   static name = "Subproof";
 });