occam-nominal 1.0.427 → 1.0.430

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-nominal",
   "author": "James Smith",
-  "version": "1.0.427",
+  "version": "1.0.430",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-nominal",
   "description": "Occam's Nominal language.",
@@ -11,16 +11,16 @@
   },
   "dependencies": {
     "necessary": "^17.6.3",
-    "occam-furtle": "^3.0.436",
+    "occam-furtle": "^3.0.438",
     "occam-grammar-utilities": "^8.1.22",
-    "occam-languages": "^2.2.53",
+    "occam-languages": "^2.2.55",
     "occam-query": "^4.1.203"
   },
   "devDependencies": {
     "@swc/core": "1.13.20",
     "decaf-cli": "^1.0.37",
-    "occam-model": "^1.0.570",
-    "occam-server": "^7.0.70",
+    "occam-model": "^1.0.572",
+    "occam-server": "^7.0.72",
     "watchful-cli": "^1.7.102"
   },
   "scripts": {

package/src/context/file/nominal.js

@@ -621,17 +621,24 @@ export default class NominalFileContext extends FileContext {
 
   isLabelPresentByLabelNode(labelNode) {
     const labels = this.getLabels(),
-          labelPresent = labels.some((label) => {
-            const labelNodeMatches = label.matchLabelNode(labelNode);
+      labelPresent = labels.some((label) => {
+        const labelNodeMatches = label.matchLabelNode(labelNode);
 
-            if (labelNodeMatches) {
-              return true;
-            }
-          });
+        if (labelNodeMatches) {
+          return true;
+        }
+      });
 
     return labelPresent;
   }
 
+  isAxiomPresentByReference(reference) {
+    const axiom = this.findAxiomByReference(reference),
+          axiomPresent = (axiom !== null);
+
+    return axiomPresent;
+  }
+
   isTypePresentByTypeName(typeName, includeRelease = true) {
     const type = this.findTypeByTypeName(typeName, includeRelease),
           typePresent = (type !== null);

package/src/context.js

@@ -417,9 +417,16 @@ export default class Context extends ContextBase {
     return declaredMetavariable;
   }
 
+  isAxiomPresentByReference(reference) {
+    const context = this.getContext(),
+          axiomPresent = context.isAxiomPresentByReference(reference);
+
+    return axiomPresent;
+  }
+
   isTermPresentByTermNode(termNode) {
     const context = this.getContext(),
-          termPresent = context.isTermPresentByTermNode(termNode);
+      termPresent = context.isTermPresentByTermNode(termNode);
 
     return termPresent;
   }

package/src/element/assertion/signature.js

@@ -5,23 +5,23 @@ import { breakPointUtilities } from "occam-languages";
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
+import { all, every } from "../../utilities/continuation";
 import { reconcile, instantiate } from "../../utilities/context";
 import { instantiateSignatureAssertion } from "../../process/instantiate";
-import { signatureFromSignatureAssertionNode, referenceFromSignatureAssertionNode, signatureAssertionFromStatementNode } from "../../utilities/element";
-import {all, exists} from "../../utilities/continuation";
+import { termsFromSignatureAssertionNode, referenceFromSignatureAssertionNode, signatureAssertionFromStatementNode } from "../../utilities/element";
 
 const { breakPointFromJSON } = breakPointUtilities;
 
 export default define(class SignatureAssertion extends Assertion {
-  constructor(context, string, node, breakPoint, signature, reference) {
+  constructor(context, string, node, breakPoint, terms, reference) {
     super(context, string, node, breakPoint);
 
-    this.signature = signature;
+    this.terms = terms;
     this.reference = reference;
   }
 
-  getSignature() {
-    return this.signature;
+  getTerms() {
+    return this.terms;
   }
 
   getReference() {
@@ -55,11 +55,11 @@ export default define(class SignatureAssertion extends Assertion {
     } else {
       assertion = this; ///
 
-      const validateSignature = this.validateSignature.bind(this),
+      const validateTerms = this.validateTerms.bind(this),
             validateReference = this.validateReference.bind(this);
 
       validates = all([
-        validateSignature,
+        validateTerms,
         validateReference
       ], state, context, (state, context) => {
         let validates;
@@ -81,91 +81,91 @@ export default define(class SignatureAssertion extends Assertion {
     return validates;
   }
 
-  validateSignature(context) {
-    let signatureValidates = false;
+  validateTerm(term, terms, state, context, continuation) {
+    let termValidates;
 
-    const signatureAssertionString = this.getString(); ///
+    const termString = term.getString(),
+          signatureAssertionString = this.getString();  ///
 
-    context.trace(`Validating the '${signatureAssertionString}' signature assertion's signature...`);
+    context.trace(`Validating the '${signatureAssertionString}' signature assertion's '${termString}' term...`);
 
-    const signature = this.signature.validate(state, context);
+    termValidates = term.validate(state, context, (term, context) => {
+      let validates;
 
-    if (signature !== null) {
-      this.signature = signature;
+      terms.push(term);
 
-      signatureValidates = true;
-    }
+      validates = continuation(terms, state, context);
+
+      return validates;
+    });
 
-    if (signatureValidates) {
-      context.debug(`...validated the '${signatureAssertionString}' signature assertion's signature.`);
+    if (termValidates) {
+      context.debug(`...validated the '${signatureAssertionString}' signature assertion's '${termString}' term.`);
     }
 
-    return signatureValidates;
+    return termValidates;
   }
 
-  validateReference(context) {
-    let referenceVerifies = false;
+  validateTerms(state, context, continuation) {
+    let termsValidate;
 
     const signatureAssertionString = this.getString();  ///
 
-    context.trace(`Validating the '${signatureAssertionString}' signature assertion's reference...`);
-
-    const reference = this.reference.validate(state, context);
-
-    if (reference !== null) {
-      const axiom = context.findAxiomByReference(reference);
-
-      if (axiom !== null) {
-        const satisfiable = axiom.isSatisfiable();
-
-        if (satisfiable) {
-          const signatureUnifies = this.unifySignature(context);
+    context.trace(`Validating the '${signatureAssertionString}' signature assertion's terms...`);
 
-          if (signatureUnifies) {
-            this.reference = reference;
+    const terms = [],
+          validateTerm = this.validateTerm.bind(this);
 
-            referenceVerifies = true;
-          }
-        } else {
-          const axiomString = axiom.getString();
+    termsValidate = every(this.terms, validateTerm, terms, state, context, (terms, state, context) => {
+      let termsValidate;
 
-          context.debug(`The '${axiomString}' axiom is not satisfiable.`);
-        }
-      } else {
-        const referencdString = reference.getString();
+      termsValidate = continuation(state, context);
 
-        context.debug(`There is no axiom for the '${referencdString}' reference.`);
+      if (termsValidate) {
+        this.terms = terms;
       }
-    }
 
-    if (referenceVerifies) {
-      context.debug(`...validated the '${signatureAssertionString}' signature assertion's reference.`);
+      return termsValidate;
+    });
+
+    if (termsValidate){
+      context.debug(`...validated the '${signatureAssertionString}' signature assertion's terms.`);
     }
 
-    return referenceVerifies;
+    return termsValidate
   }
 
-  unifySignature(context) {
-    let signatureUnifies;
+  validateReference(state, context, continuation) {
+    let referenceValidates;
 
     const signatureAssertionString = this.getString();  ///
 
-    context.trace(`Unifying the '${signatureAssertionString}' signature assertion's signature...`);
+    context.trace(`Validating the '${signatureAssertionString}' signature assertion's reference...`);
 
-    return reconcile((context) => {
-      const axiom = context.findAxiomByReference(this.reference);
+    referenceValidates = this.reference.validate(state, context, (reference, context) => {
+      let validates = false;
 
-      signatureUnifies = axiom.unifySignature(this.signature, context);
-    }, context);
+      const asiomPresent = context.isAxiomPresentByReference(reference);
+
+      if (asiomPresent) {
+        this.reference = reference;
+
+        validates = continuation(state, context);
+      }
 
-    if (signatureUnifies) {
-      context.debug(`...unified the '${signatureAssertionString}' signature assertion's signature.`);
+      return validates;
+    });
+
+    if (referenceValidates) {
+      context.debug(`...validated the '${signatureAssertionString}' signature assertion's reference.`);
     }
 
-    return signatureUnifies;
+    return referenceValidates;
   }
 
-  async unifyClaim(claim, context) {
+  unifyClaim(claim, context) {
+    debugger
+
     let claimUnifies;
 
     const claimString = claim.getString(),
@@ -173,12 +173,12 @@ export default define(class SignatureAssertion extends Assertion {
 
     context.trace(`Unifying the '${claimString}' claim with the '${signatureAssertionString}' signature assertion...`);
 
-    await reconcile(async (context) => {
+    reconcile((context) => {
       const axiom = context.findAxiomByReference(this.reference);
 
       axiom.unifySignature(this.signature, context);
 
-      claimUnifies = await axiom.unifyClaim(claim, context);
+      claimUnifies = axiom.unifyClaim(claim, context);
     }, context);
 
     if (claimUnifies) {
@@ -188,18 +188,23 @@ export default define(class SignatureAssertion extends Assertion {
     return claimUnifies;
   }
 
-  async unifyStepAndFactOrSubproofs(step, factOrSubproofs, context) {
-    let stepAndFactOrSubproofsUnify;
+  unifyStepAndFactOrSubproofs(step, factOrSubproofs, context, continuation) {
+    let stepAndFactOrSubproofsUnify = false;
 
-    await reconcile(async (context) => {
-      const axiom = context.findAxiomByReference(this.reference);
+    return reconcile((context) => {
+      const axiom = context.findAxiomByReference(this.reference),
+            signatureAssertion = this;  ///
 
-      axiom.unifySignature(this.signature, context);
+      return axiom.unifySignatureAssertion(signatureAssertion, context, (signatureAssertionUnifies) => {
+        if (!signatureAssertionUnifies) {
+          return continuation(stepAndFactOrSubproofsUnify);
+        }
 
-      stepAndFactOrSubproofsUnify = await axiom.unifyStepAndFactOrSubproofs(step, factOrSubproofs, context);
-    }, context);
+        debugger
 
-    return stepAndFactOrSubproofsUnify;
+        // stepAndFactOrSubproofsUnify = axiom.unifyStepAndFactOrSubproofs(step, factOrSubproofs, context);
+      });
+    }, context);
   }
 
   static name = "SignatureAssertion";
@@ -215,12 +220,12 @@ export default define(class SignatureAssertion extends Assertion {
               definedAssertionNode = instantiateSignatureAssertion(string, context),
               node = definedAssertionNode,  ///
               breakPoint = breakPointFromJSON(json),
-              signature = signatureFromSignatureAssertionNode(definedAssertionNode, context),
+              terms = termsFromSignatureAssertionNode(definedAssertionNode, context),
               reference = referenceFromSignatureAssertionNode(definedAssertionNode, context);
 
         context = null;
 
-        signatureAssertion = new SignatureAssertion(context, string, node, breakPoint, signature, reference);
+        signatureAssertion = new SignatureAssertion(context, string, node, breakPoint, terms, reference);
       }, context);
     }
 

package/src/element/claim/axiom.js

@@ -60,13 +60,12 @@ export default define(class Axiom extends Claim {
       return continuation(signatureVerifies);
     }
 
-    const axiomString = this.getString(); ///
+    const signature = this.getSignature(),
+          axiomString = this.getString(); ///
 
     context.trace(`Verifying the '${axiomString}' axiom's signature...`);
 
-    const signature = this.getSignature();
-
-    signature.verify(context, (signatureVerifies) => {
+    return signature.verify(context, (signatureVerifies) => {
       if (signatureVerifies) {
         context.trace(`...verified the '${axiomString}' axiom's signature.`);
       }
@@ -75,30 +74,66 @@ export default define(class Axiom extends Claim {
     });
   }
 
-  unifySignature(signature, context) {
-    let signatureUnifies;
+  unifyClaim(claim, context) {
+    debugger
+
+    let claimUnifies = false;
 
     const axiomString = this.getString(), ///
-          signatureString = signature.getString();
+          claimString = claim.getString();
 
-    context.trace(`Unifying the '${signatureString}' signature with the '${axiomString}' axiom...`);
+    context.trace(`Unifying the '${claimString}' claim with the '${axiomString}' axiom...`);
 
-    const specificSignature = signature;  ///
+    const deduction = claim.getDeduction(),
+          deductionUnifies = this.unifyDeduction(deduction, context);
 
-    signature = this.getSignature();
+    if (deductionUnifies) {
+      const hypothesesDischarges = claim.dischargeHypotheses(context);
 
-    const generalSignature = signature; ///
+      if (hypothesesDischarges) {
+        const suppositions = claim.getSuppositions(),
+              suppositionsUnify = this.unifySuppositions(suppositions, context);
 
-    signatureUnifies = generalSignature.unifySignature(specificSignature, context);
+        if (suppositionsUnify) {
+          claimUnifies = true;
+        }
+      }
+    }
 
-    if (signatureUnifies) {
-      context.debug(`...unified the '${signatureString}' signature with the '${axiomString}' axiom.`);
+    if (claimUnifies) {
+      context.debug(`...unified the '${claimString}' claim with the '${axiomString}' axiom.`);
     }
 
-    return signatureUnifies;
+    return claimUnifies;
+  }
+
+  unifySignatureAssertion(signatureAssertion, context, continuation) {
+    let signatureAssertionUnifies = false;
+
+    const axiomString = this.getString(), ///
+          signatureAssertionString = signatureAssertion.getString();
+
+    context.trace(`Unifying the '${signatureAssertionString}' signature assertion with the '${axiomString}' axiom...`);
+
+    const terms = signatureAssertion.getTerms(),
+          signature = this.getSignature();
+
+    return signature.unifyTerms(terms, context, (termsUnify) => {
+      if (termsUnify) {
+        signatureAssertionUnifies = true;
+      }
+
+      if (signatureAssertionUnifies) {
+        context.debug(`...unified the '${signatureAssertionString}' signature assertion with the '${axiomString}' axiom.`);
+      }
+
+      return continuation(signatureAssertionUnifies);
+    });
   }
 
   unifyDeduction(deduction, context) {
+    debugger
+
     let deductionUnifies;
 
     const axiomString = this.getString(), ///
@@ -143,6 +178,8 @@ export default define(class Axiom extends Claim {
   }
 
   unifySupposition(supposition, index, context) {
+    debugger
+
     let suppositionUnifies = false;
 
     const specificSupposition = supposition;  ///
@@ -190,6 +227,8 @@ export default define(class Axiom extends Claim {
   }
 
   unifySuppositions(suppositions, context) {
+    debugger
+
     let suppositionsUnify;
 
     const specificSuppositions = suppositions;  ///
@@ -210,37 +249,6 @@ export default define(class Axiom extends Claim {
     return suppositionsUnify;
   }
 
-  unifyClaim(claim, context) {
-    let claimUnifies = false;
-
-    const axiomString = this.getString(), ///
-          claimString = claim.getString();
-
-    context.trace(`Unifying the '${claimString}' claim with the '${axiomString}' axiom...`);
-
-    const deduction = claim.getDeduction(),
-          deductionUnifies = this.unifyDeduction(deduction, context);
-
-    if (deductionUnifies) {
-      const hypothesesDischarges = claim.dischargeHypotheses(context);
-
-      if (hypothesesDischarges) {
-        const suppositions = claim.getSuppositions(),
-              suppositionsUnify = this.unifySuppositions(suppositions, context);
-
-        if (suppositionsUnify) {
-          claimUnifies = true;
-        }
-      }
-    }
-
-    if (claimUnifies) {
-      context.debug(`...unified the '${claimString}' claim with the '${axiomString}' axiom.`);
-    }
-
-    return claimUnifies;
-  }
-
   static name = "Axiom";
 
   static fromJSON(json, context) { return Claim.fromJSON(Axiom, json, context); }

package/src/element/label.js

@@ -249,10 +249,10 @@ export default define(class Label extends Element {
 
     ablate((context) => {
       instantiate((context) => {
-      const string = labelString,  ///
-            labelNode = instantiateLabel(string, context);
+        const string = labelString,  ///
+              labelNode = instantiateLabel(string, context);
 
-      label = labelFromLabelNode(labelNode, context);
+        label = labelFromLabelNode(labelNode, context);
       }, context);
     }, context);