occam-verify-cli 1.0.902 → 1.0.905

package/src/element/equality.js

@@ -183,9 +183,9 @@ export default define(class Equality extends Element {
 
           const leftTermType = leftTerm.getType(),
                 rightTermType = rightTerm.getType(),
-                leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
+                leftTermTypeEqualToSubTypeOrSuperTypeOfRightTermType = leftTermType.isEqualToSubTypeOrSuperTypeOf(rightTermType);
 
-          if (leftTermTypeComparableToRightTermType) {
+          if (leftTermTypeEqualToSubTypeOrSuperTypeOfRightTermType) {
             validatesForwards = true;
           }
 

package/src/element/signature.js

@@ -6,9 +6,9 @@ import { arrayUtilities } from "necessary";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
 import { instantiateSignature } from "../process/instantiate";
 import { termsFromSignatureNode } from "../utilities/element";
+import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 const { match, compare, correlate } = arrayUtilities;
 
@@ -37,11 +37,17 @@ export default define(class Signature extends Element {
 
     context.trace(`Verifying the '${signatureString}' signature...`);
 
-    const signature = this.validate(context);
+    attempt((context) => {
+      const termsValidate = this.validateTerms(context);
 
-    if (signature !== null) {
-      verifies = true;
-    }
+      if (termsValidate !== null) {
+        verifies = true;
+      }
+
+      if (verifies) {
+        this.commit(context);
+      }
+    }, context);
 
     if (verifies) {
       context.debug(`...verified the '${signatureString}' signature.`);
@@ -50,71 +56,33 @@ export default define(class Signature extends Element {
     return verifies;
   }
 
-  validate(context) {
-    let signature = null;
+  validateTerms(context) {
+    let termsValidate;
 
     const signatureString = this.getString();  ///
 
-    context.trace(`Validating the '${signatureString}' signature...`);
-
-    const terms = [],
-          termsValidate = this.validateTerms(terms, context);
-
-    if (termsValidate) {
-      this.terms = terms;
-
-      signature = this; ///
-    }
-
-    if (signature) {
-      context.debug(`...validated the '${signatureString}' signature.`);
-    }
-
-    return signature
-  }
+    context.trace(`Validating the '${signatureString}' signature's terms...`);
 
-  validateTerm(term, terms, context) {
-    let termValidates = false;
+    const terms = [];
 
-    const termString = term.getString(),
-          signatureString = this.getString();  ///
+    termsValidate = this.terms.every((term) => {
+      term = term.validate(context, (term) => { ///
+        const validatesForwards = true;
 
-    context.trace(`Validating the '${signatureString}' signature's '${termString}' term...`);
+        return validatesForwards;
+      });
 
-    term = term.validate(context, (term) => { ///
-      const validatesForwards = true;
+      if (term !== null) {
+        terms.push(term);
 
-      return validatesForwards;
+        return true;
+      }
     });
 
-    if (term !== null) {
-      terms.push(term);
-
-      termValidates = true;
-    }
-
-    if (termValidates) {
-      context.debug(`...validated the '${signatureString}' signature's '${termString}' term.`);
+    if (termsValidate) {
+      this.terms = terms;
     }
 
-    return termValidates
-  }
-
-  validateTerms(terms, context) {
-    let termsValidate;
-
-    const signatureString = this.getString();  ///
-
-    context.trace(`Validating the '${signatureString}' signature's terms...`);
-
-    termsValidate = terms.every((term) => {
-      const termValidates = this.validateTerm(term, terms, context);
-
-      if (termValidates) {
-        return true;
-      }
-    })
-
     if (termsValidate){
       context.debug(`...validated the '${signatureString}' signature's terms.`);
     }
@@ -219,25 +187,35 @@ export default define(class Signature extends Element {
   static name = "Signature";
 
   toJSON() {
-    const string = this.getString(),
-          lineIndex = this.getLineIndex(),
-          json = {
-            string,
-            lineIndex
-          };
-
-    return json;
+    const context = this.getContext();
+
+    return serialise((context) => {
+      const string = this.getString(),
+            lineIndex = this.getLineIndex(),
+            json = {
+              context,
+              string,
+              lineIndex
+            };
+
+      return json;
+    }, context);
   }
 
   static fromJSON(json, context) {
-    return instantiate((context) => {
-      const { string, lineIndex } = json,
-            signatureNode = instantiateSignature(string, context),
-            node = signatureNode,  ///
-            terms = termsFromSignatureNode(signatureNode, context),
-            signature = new Signature(context, string, node, lineIndex, terms);
-
-      return signature;
-    }, context);
+    let signature;
+
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string, lineIndex } = json,
+              signatureNode = instantiateSignature(string, context),
+              node = signatureNode,  ///
+              terms = termsFromSignatureNode(signatureNode, context);
+
+        signature = new Signature(context, string, node, lineIndex, terms);
+      }, context);
+    }, json, context);
+
+    return signature;
   }
 });

package/src/element/topLevelAssertion/axiom.js

@@ -58,7 +58,7 @@ export default define(class Axiom extends TopLevelAssertion {
 
     context.trace(`Verifying the '${axiomString}' axiom...`);
 
-    const signatureVerifies = this.verifySignature();
+    const signatureVerifies = this.verifySignature(context);
 
     if (signatureVerifies) {
       verifies = await super.verify(context);
@@ -75,16 +75,23 @@ export default define(class Axiom extends TopLevelAssertion {
     return verifies;
   }
 
-  verifySignature() {
+  verifySignature(context) {
     let signatureVerifies;
 
     const satisfiable = this.isSatisfiable();
 
     if (satisfiable) {
-      const context = this.getContext(),
-            signature = this.getSignature();
+      const axiomString = this.getString(); ///
+
+      context.trace(`Verifying the '${axiomString}' axiom's signature...`);
+
+      const signature = this.getSignature();
 
       signatureVerifies = signature.verify(context);
+
+      if (signatureVerifies) {
+        context.trace(`...verified the '${axiomString}' axiom's signature.`);
+      }
     } else {
       signatureVerifies = true
     }

package/src/element/type.js

@@ -210,15 +210,6 @@ export default define(class Type extends Element {
     return superTypeOf;
   }
 
-  isComparableTo(type) {
-    const equalTo = this.isEqualTo(type),
-          subTypeOf = this.isSubTypeOf(type),
-          superTypeOf = this.isSuperTypeOf(type),
-          comparableTo = (equalTo || subTypeOf || superTypeOf);
-
-    return comparableTo;
-  }
-
   isEqualToOrSubTypeOf(type) {
     const equalTo = this.isEqualTo(type),
           subTypeOf = this.isSubTypeOf(type),
@@ -235,6 +226,15 @@ export default define(class Type extends Element {
     return equalToOrSuperTypeOf;
   }
 
+  isEqualToSubTypeOrSuperTypeOf(type) {
+    const equalTo = this.isEqualTo(type),
+          subTypeOf = this.isSubTypeOf(type),
+          superTypeOf = this.isSuperTypeOf(type),
+          equalToSubTypeOrSuperTypeOf = (equalTo || subTypeOf || superTypeOf);
+
+    return equalToSubTypeOrSuperTypeOf;
+  }
+
   compareTypeName(typeName) {
     const nameTypeName = (this.name === typeName),
           comparesToTypeName = nameTypeName;  ///

package/src/utilities/assignment.js

@@ -11,9 +11,9 @@ export function variableAssignmentFromTermAndType(term, type, context) {
 
   if (termSingular) {
     const termType = term.getType(),
-          termTypeEqualToType = termType.isEqualTo(type);
+          termTypeSuperTypeOfType = termType.isSuperTypeOf(type);
 
-    if (!termTypeEqualToType) {
+    if (termTypeSuperTypeOfType) {
       const variableNode = term.getVariableNode(),
             variable = variableFromVariableNode(variableNode, context);
 

package/src/utilities/element.js

@@ -1166,7 +1166,7 @@ export function frameFromJudgementNode(judgementNode, context) {
 }
 
 export function termsFromSignatureNode(signatureNode, context) {
-  const termNodes = signatureNode.getAssumptionNodes(),
+  const termNodes = signatureNode.getTermNodes(),
         terms = termsFromTermNodes(termNodes, context);
 
   return terms;

package/src/utilities/json.js

@@ -518,11 +518,11 @@ export function referencesFromJSON(json, context) {
   let { references } = json;
 
   const { Reference } = elements,
-        referencesJSON = references; ///
+    referencesJSON = references; ///
 
   references = referencesJSON.map((referenceJSON) => {
     const json = referenceJSON,  ///
-          reference = Reference.fromJSON(json, context);
+      reference = Reference.fromJSON(json, context);
 
     return reference;
   });
@@ -530,6 +530,22 @@ export function referencesFromJSON(json, context) {
   return references;
 }
 
+export function signaturesFromJSON(json, context) {
+  let { signatures } = json;
+
+  const { Signature } = elements,
+        signaturesJSON = signatures; ///
+
+  signatures = signaturesJSON.map((signatureJSON) => {
+    const json = signatureJSON,  ///
+          signature = Signature.fromJSON(json, context);
+
+    return signature;
+  });
+
+  return signatures;
+}
+
 export function conjecturesFromJSON(json, context) {
   let { conjectures } = json;
 
@@ -1072,6 +1088,16 @@ export function statementsToStatementsJSON(statements) {
   return statementsJSON;
 }
 
+export function signaturesToSignaturesJSON(signatures) {
+  const signaturesJSON = signatures.map((signature) => {
+    const signatureJSON = signature.toJSON();
+
+    return signatureJSON;
+  });
+
+  return signaturesJSON;
+}
+
 export function assertionsToAssertionsJSON(assertions) {
   const assertionsJSON = assertions.map((assertion) => {
     const assertionJSON = assertion.toJSON();

package/src/utilities/synoptic.js

@@ -74,6 +74,16 @@ export function compressStatements(statements) {
   });
 }
 
+export function compressSignatures(signatures) {
+  compress(signatures, (signatureA, signatureB) => {
+    const signatureAEqualToSignatureB = signatureA.isEqualTo(signatureB);
+
+    if (!signatureAEqualToSignatureB) {
+      return true;
+    }
+  });
+}
+
 export function compressReferences(references) {
   compress(references, (referenceA, referenceB) => {
     const referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);