occam-verify-cli 1.0.902 → 1.0.905

package/src/context/mnemic.js

@@ -11,6 +11,7 @@ import { compressTerms,
          compressJudgements,
          compressAssertions,
          compressStatements,
+         compressSignatures,
          compressReferences,
          compressAssumptions,
          compressMetavariables,
@@ -26,6 +27,7 @@ import { termsFromJSON,
          statementsFromJSON,
          assertionsFromJSON,
          referencesFromJSON,
+         signaturesFromJSON,
          assumptionsFromJSON,
          metavariablesFromJSON,
          substitutionsFromJSON,
@@ -34,6 +36,7 @@ import { termsFromJSON,
          judgementsToJudgementsJSON,
          equalitiesToEqualitiesJSON,
          statementsToStatementsJSON,
+         signaturesToSignaturesJSON,
          assertionsToAssertionsJSON,
          referencesToReferencesJSON,
          assumptionsToAssumptionsJSON,
@@ -44,7 +47,7 @@ import { termsFromJSON,
 const { push } = arrayUtilities;
 
 export default class MnemicContext extends Context {
-  constructor(context, terms, frames, properties, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions, propertyRelations) {
+  constructor(context, terms, frames, properties, equalities, judgements, assertions, statements, signatures, references, assumptions, metavariables, substitutions, propertyRelations) {
     super(context);
 
     this.terms = terms;
@@ -54,6 +57,7 @@ export default class MnemicContext extends Context {
     this.judgements = judgements;
     this.assertions = assertions;
     this.statements = statements;
+    this.signatures = signatures;
     this.references = references;
     this.assumptions = assumptions;
     this.metavariables = metavariables;
@@ -133,6 +137,18 @@ export default class MnemicContext extends Context {
     return statements;
   }
 
+  getSignatures(signatures = []) {
+    const context = this.getContext();
+
+    push(signatures, this.signatures);
+
+    context.getSignatures(signatures);
+
+    compressSignatures(context);
+
+    return signatures;
+  }
+
   getAssertions(assertions = []) {
     const context = this.getContext();
 
@@ -260,6 +276,17 @@ export default class MnemicContext extends Context {
     context.debug(`...added the '${judgementString}' judgement to the mnemic context.`);
   }
 
+  addAssertion(assertion) {
+    const context = this, ///
+          assertionString = assertion.getString();
+
+    context.trace(`Adding the '${assertionString}' assertion to the mnemic context...`);
+
+    this.assertions.push(assertion);
+
+    context.debug(`...added the '${assertionString}' assertion to the mnemic context.`);
+  }
+
   addStatement(statement) {
     const context = this, ///
           statementString = statement.getString();
@@ -271,15 +298,15 @@ export default class MnemicContext extends Context {
     context.debug(`...added the '${statementString}' statement to the mnemic context.`);
   }
 
-  addAssertion(assertion) {
+  addSignature(signature) {
     const context = this, ///
-          assertionString = assertion.getString();
+          signatureString = signature.getString();
 
-    context.trace(`Adding the '${assertionString}' assertion to the mnemic context...`);
+    context.trace(`Adding the '${signatureString}' signature to the mnemic context...`);
 
-    this.assertions.push(assertion);
+    this.signatures.push(signature);
 
-    context.debug(`...added the '${assertionString}' assertion to the mnemic context.`);
+    context.debug(`...added the '${signatureString}' signature to the mnemic context.`);
   }
 
   addReference(reference) {
@@ -408,6 +435,19 @@ export default class MnemicContext extends Context {
     return judgement;
   }
 
+  findAssertionByAssertionNode(assertionNode) {
+    const assertions = this.getAssertions(),
+          assertion = assertions.find((assertion) => {
+            const assertionNodeMatches = assertion.matchAssertionNode(assertionNode);
+
+            if (assertionNodeMatches) {
+              return true;
+            }
+          }) || null;
+
+    return assertion;
+  }
+
   findStatementByStatementNode(statementNode) {
     const statements = this.getStatements(),
           statement = statements.find((statement) => {
@@ -421,30 +461,30 @@ export default class MnemicContext extends Context {
     return statement;
   }
 
-  findReferenceByReferenceNode(referenceNode) {
-    const references = this.getReferences(),
-          reference = references.find((reference) => {
-            const referenceMatcheReferenceNode = reference.matchReferenceNode(referenceNode);
+  findSignatureBySignatureNode(signatureNode) {
+    const signatures = this.getSignatures(),
+          signature = signatures.find((signature) => {
+            const signatureNodeMatches = signature.matchSignatureNode(signatureNode);
 
-            if (referenceMatcheReferenceNode) {
+            if (signatureNodeMatches) {
               return true;
             }
           }) || null;
 
-    return reference;
+    return signature;
   }
 
-  findAssertionByAssertionNode(assertionNode) {
-    const assertions = this.getAssertions(),
-          assertion = assertions.find((assertion) => {
-            const assertionNodeMatches = assertion.matchAssertionNode(assertionNode);
+  findReferenceByReferenceNode(referenceNode) {
+    const references = this.getReferences(),
+          reference = references.find((reference) => {
+            const referenceMatcheReferenceNode = reference.matchReferenceNode(referenceNode);
 
-            if (assertionNodeMatches) {
+            if (referenceMatcheReferenceNode) {
               return true;
             }
           }) || null;
 
-    return assertion;
+    return reference;
   }
 
   findAssumptionByAssumptionNode(assumptionNode) {
@@ -555,6 +595,13 @@ export default class MnemicContext extends Context {
     return judgementPresent;
   }
 
+  isAssertionPresentByAssertionNode(assertionNode) {
+    const assertion = this.findAssertionByAssertionNode(assertionNode),
+          assertionPresent = (assertion !== null);
+
+    return assertionPresent;
+  }
+
   isStatementPresentByStatementNode(statementNode) {
     const statement = this.findStatementByStatementNode(statementNode),
           statementPresent = (statement !== null);
@@ -562,11 +609,11 @@ export default class MnemicContext extends Context {
     return statementPresent;
   }
 
-  isAssertionPresentByAssertionNode(assertionNode) {
-    const assertion = this.findAssertionByAssertionNode(assertionNode),
-          assertionPresent = (assertion !== null);
+  isSignaturePresentBySignatureNode(signatureNode) {
+    const signature = this.findSignatureBySignatureNode(signatureNode),
+          signaturePresent = (signature !== null);
 
-    return assertionPresent;
+    return signaturePresent;
   }
 
   isAssumptionPresentByAssumptionNode(assumptionNode) {
@@ -629,6 +676,7 @@ export default class MnemicContext extends Context {
 
     this.judgements = judgementsFromJSON(json, context);
     this.assertions = assertionsFromJSON(json, context);
+    this.signatures = signaturesFromJSON(json, context);
     this.substitutions = substitutionsFromJSON(json, context);
     this.propertyRelations = propertyRelationsFromJSON(json, context);
   }
@@ -637,10 +685,11 @@ export default class MnemicContext extends Context {
     let terms = this.getTerms(),
         frames = this.getFrames(),
         properties = this.getProperties(),
-        judgements = this.getJudgements(),
         equalities = this.getEqualities(),
-        statements = this.getStatements(),
+        judgements = this.getJudgements(),
         assertions = this.getAssertions(),
+        statements = this.getStatements(),
+        signatures = this.getSignatures(),
         references = this.getReferences(),
         assumptions = this.getAssumptions(),
         metavariables = this.getMetavariables(),
@@ -650,10 +699,11 @@ export default class MnemicContext extends Context {
     const termsJSON = termsToTermsJSON(terms),
           framesJSON = framesToFramesJSON(frames),
           propertiesJSON = propertiesToPropertiesJSON(properties),
-          judgementsJSON = judgementsToJudgementsJSON(judgements),
           equalitiesJSON = equalitiesToEqualitiesJSON(equalities),
-          statementsJSON = statementsToStatementsJSON(statements),
+          judgementsJSON = judgementsToJudgementsJSON(judgements),
           assertionsJSON = assertionsToAssertionsJSON(assertions),
+          statementsJSON = statementsToStatementsJSON(statements),
+          signaturesJSON = signaturesToSignaturesJSON(signatures),
           referencesJSON = referencesToReferencesJSON(references),
           assumptionsJSON = assumptionsToAssumptionsJSON(assumptions),
           metavariablesJSON = metavariablesToMetavariablesJSON(metavariables),
@@ -663,10 +713,11 @@ export default class MnemicContext extends Context {
     terms = termsJSON; ///
     frames = framesJSON; ///
     properties = propertiesJSON;  ///
-    judgements = judgementsJSON; ///
     equalities = equalitiesJSON; ///
-    statements = statementsJSON; ///
+    judgements = judgementsJSON; ///
     assertions = assertionsJSON; ///
+    statements = statementsJSON; ///
+    signatures = signaturesJSON; ///
     references = referencesJSON; ///
     assumptions = assumptionsJSON; ///
     metavariables = metavariablesJSON;  //
@@ -679,8 +730,9 @@ export default class MnemicContext extends Context {
       properties,
       equalities,
       judgements,
-      statements,
       assertions,
+      statements,
+      signatures,
       references,
       assumptions,
       metavariables,
@@ -699,12 +751,13 @@ export default class MnemicContext extends Context {
           judgements = null,
           statements = null,
           assertions = null,
+          signatures = null,
           references = null,
           assumptions = null,
           metavariables = null,
           substitutions = null,
           propertyRelations = null,
-          mnemicContext = new MnemicContext(context, terms, frames, properties, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions, propertyRelations);
+          mnemicContext = new MnemicContext(context, terms, frames, properties, equalities, judgements, assertions, statements, signatures, references, assumptions, metavariables, substitutions, propertyRelations);
 
     mnemicContext.initialise(json);
 
@@ -719,12 +772,13 @@ export default class MnemicContext extends Context {
           judgements = [],
           statements = [],
           assertions = [],
+          signatures = [],
           references = [],
           assumptions = [],
           metavariables = [],
           substitutions = [],
           propertyRelations = [],
-          mnemicContext = new MnemicContext(context, terms, frames, properties, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions, propertyRelations);
+          mnemicContext = new MnemicContext(context, terms, frames, properties, equalities, judgements, assertions, statements, signatures, references, assumptions, metavariables, substitutions, propertyRelations);
 
     return mnemicContext;
   }

package/src/context/synoptic.js

@@ -11,6 +11,7 @@ import { compressTerms,
          compressJudgements,
          compressAssertions,
          compressStatements,
+         compressSignatures,
          compressReferences,
          compressAssumptions,
          compressMetavariables,
@@ -80,6 +81,16 @@ export default class SynopticContext extends Context {
     return judgements;
   }
 
+  getAssertions(assertions = []) {
+    this.contexts.forEach((context) => {
+      context.getAssertions(assertions);
+    });
+
+    compressAssertions(assertions);
+
+    return assertions;
+  }
+
   getStatements(statements = []) {
     this.contexts.forEach((context) => {
       context.getStatements(statements);
@@ -90,14 +101,14 @@ export default class SynopticContext extends Context {
     return statements;
   }
 
-  getAssertions(assertions = []) {
+  getSignatures(signatures = []) {
     this.contexts.forEach((context) => {
-      context.getAssertions(assertions);
+      context.getSignatures(signatures);
     });
 
-    compressAssertions(assertions);
+    compressSignatures(signatures);
 
-    return assertions;
+    return signatures;
   }
 
   getReferences(references = []) {
@@ -215,6 +226,19 @@ export default class SynopticContext extends Context {
     return judgement;
   }
 
+  findAssertionByAssertionNode(assertionNode) {
+    const assertions = this.getAssertions(),
+          assertion = assertions.find((assertion) => {
+            const assertionNodeMatches = assertion.matchAssertionNode(assertionNode);
+
+            if (assertionNodeMatches) {
+              return true;
+            }
+          }) || null;
+
+    return assertion;
+  }
+
   findStatementByStatementNode(statementNode) {
     const statements = this.getStatements(),
           statement = statements.find((statement) => {
@@ -228,30 +252,30 @@ export default class SynopticContext extends Context {
     return statement;
   }
 
-  findReferenceByReferenceNode(referenceNode) {
-    const references = this.getReferences(),
-          reference = references.find((reference) => {
-            const referenceMatcheReferenceNode = reference.matchReferenceNode(referenceNode);
+  findSignatureBySignatureNode(signatureNode) {
+    const signatures = this.getSignatures(),
+          signature = signatures.find((signature) => {
+            const signatureNodeMatches = signature.matchSignatureNode(signatureNode);
 
-            if (referenceMatcheReferenceNode) {
+            if (signatureNodeMatches) {
               return true;
             }
           }) || null;
 
-    return reference;
+    return signature;
   }
 
-  findAssertionByAssertionNode(assertionNode) {
-    const assertions = this.getAssertions(),
-          assertion = assertions.find((assertion) => {
-            const assertionNodeMatches = assertion.matchAssertionNode(assertionNode);
+  findReferenceByReferenceNode(referenceNode) {
+    const references = this.getReferences(),
+          reference = references.find((reference) => {
+            const referenceMatcheReferenceNode = reference.matchReferenceNode(referenceNode);
 
-            if (assertionNodeMatches) {
+            if (referenceMatcheReferenceNode) {
               return true;
             }
           }) || null;
 
-    return assertion;
+    return reference;
   }
 
   findAssumptionByAssumptionNode(assumptionNode) {

package/src/context.js

@@ -40,14 +40,6 @@ export default class Context extends ContextBase {
     return frames;
   }
 
-  getJudgements(judgements = []) {
-    const context = this.getContext();
-
-    context.getJudgements(judgements);
-
-    return judgements;
-  }
-
   getProperties(properties = []) {
     const context = this.getContext();
 
@@ -64,12 +56,12 @@ export default class Context extends ContextBase {
     return equalities;
   }
 
-  getStatements(statements = []) {
+  getJudgements(judgements = []) {
     const context = this.getContext();
 
-    context.getStatements(statements);
+    context.getJudgements(judgements);
 
-    return statements;
+    return judgements;
   }
 
   getAssertions(assertions = []) {
@@ -80,6 +72,22 @@ export default class Context extends ContextBase {
     return assertions;
   }
 
+  getStatements(statements = []) {
+    const context = this.getContext();
+
+    context.getStatements(statements);
+
+    return statements;
+  }
+
+  getSignatures(signatures = []) {
+    const context = this.getContext();
+
+    context.getSignatures(signatures);
+
+    return signatures;
+  }
+
   getReferences(references = []) {
     const context = this.getContext();
 
@@ -268,6 +276,13 @@ export default class Context extends ContextBase {
     return statement;
   }
 
+  findSignatureBySignatureNode(signatureNode) {
+    const context = this.getContext(),
+          signature = context.findSignatureBySignatureNode(signatureNode);
+
+    return signature;
+  }
+
   findReferenceByReferenceNode(referenceNode) {
     const context = this.getContext(),
           reference = context.findReferenceByReferenceNode(referenceNode);
@@ -479,6 +494,13 @@ export default class Context extends ContextBase {
     return judgementPresent;
   }
 
+  isAssertionPresentByAssertionNode(assertionNode) {
+    const context = this.getContext(),
+          assertionPresent = context.isAssertionPresentByAssertionNode(assertionNode);
+
+    return assertionPresent;
+  }
+
   isStatementPresentByStatementNode(statementNode) {
     const context = this.getContext(),
       statementPresent = context.isStatementPresentByStatementNode(statementNode);
@@ -486,11 +508,11 @@ export default class Context extends ContextBase {
     return statementPresent;
   }
 
-  isAssertionPresentByAssertionNode(assertionNode) {
+  isSignaturePresentBySignatureNode(signatureNode) {
     const context = this.getContext(),
-          assertionPresent = context.isAssertionPresentByAssertionNode(assertionNode);
+          signaturePresent = context.isSignaturePresentBySignatureNode(signatureNode);
 
-    return assertionPresent;
+    return signaturePresent;
   }
 
   isMetavariablePresentByMetavariableNode(metavariableNode) {
@@ -612,16 +634,22 @@ export default class Context extends ContextBase {
     context.addJudgement(judgement);
   }
 
+  addAssertion(assertion) {
+    const context = this.getContext();
+
+    context.addAssertion(assertion);
+  }
+
   addStatement(statement) {
     const context = this.getContext();
 
     context.addStatement(statement);
   }
 
-  addAssertion(assertion) {
+  addSignature(signature) {
     const context = this.getContext();
 
-    context.addAssertion(assertion);
+    context.addSignature(signature);
   }
 
   addReference(reference) {

package/src/element/assertion/property.js

@@ -75,12 +75,12 @@ export default define(class PropertyAssertion extends Assertion {
     } else {
       let validates = false;
 
-      const termValidates = this.validateTerm(context);
+      const propertyRelationVerifies = this.validatePropertyRelation(context);
 
-      if (termValidates) {
-        const propertyRelationVerifies = this.validatePropertyRelation(context);
+      if (propertyRelationVerifies) {
+        const termValidates = this.validateTerm(context);
 
-        if (propertyRelationVerifies) {
+        if (termValidates) {
           const stated = context.isStated();
 
           let validatesWhenStated = false,
@@ -121,11 +121,19 @@ export default define(class PropertyAssertion extends Assertion {
 
     context.trace(`Validating the '${propertyAssertionString}' property assertion's term...`);
 
-    const term = this.term.validate(context, (term) => {
-      const validatesForwards = true;
+    const type = this.getType(),
+          term = this.term.validate(context, (term) => {
+            let validatesForwards = false;
 
-      return validatesForwards;
-    });
+            const termType = term.getType(),
+                  termTypeEqualToSubTypeOrSuperTypeOfType = termType.isEqualToSubTypeOrSuperTypeOf(type);
+
+            if (termTypeEqualToSubTypeOrSuperTypeOfType) {
+              validatesForwards = true;
+            }
+
+            return validatesForwards;
+          });
 
     if (term !== null) {
       this.term = term;
@@ -134,38 +142,12 @@ export default define(class PropertyAssertion extends Assertion {
     }
 
     if (termValidates) {
-      context.debug(`...validated the '${propertyAssertionString}' property assertion's term.`);
+      context.debug(`...validated the '${propertyAssertionString}' property assertion's term...`);
     }
 
     return termValidates;
   }
 
-  validatePropertyRelation(context) {
-    let propertyRelationValidates = false;
-
-    const propertyAssertionString = this.getString(); ///
-
-    context.trace(`Validating the '${propertyAssertionString}' property assertion's property relation...`);
-
-    const propertyRelation = this.propertyRelation.validate(context);
-
-    if (propertyRelation !== null) {
-      const type = this.getType(),
-            termType = this.term.getType(),
-            termTypeEqualToOrSuperTypeOfType = termType.isEqualToOrSuperTypeOf(type);
-
-      if (termTypeEqualToOrSuperTypeOfType) {
-        propertyRelationValidates = true;
-      }
-    }
-
-    if (propertyRelationValidates) {
-      context.debug(`...validated the '${propertyAssertionString}' property assertion's property relation.`);
-    }
-
-    return propertyRelationValidates;
-  }
-
   validateWhenStated(context) {
     let validatesWhenStated;
 
@@ -176,7 +158,7 @@ export default define(class PropertyAssertion extends Assertion {
     validatesWhenStated = true;
 
     if (validatesWhenStated) {
-      context.debug(`...validated the '${propertyAssertionString}' stated property assertion.`);
+      context.debug(`...verified the '${propertyAssertionString}' stated property assertion.`);
     }
 
     return validatesWhenStated;
@@ -198,6 +180,26 @@ export default define(class PropertyAssertion extends Assertion {
     return validatesWhenDerived;
   }
 
+  validatePropertyRelation(context) {
+    let propertyRelationValidates = false;
+
+    const propertyAssertionString = this.getString(); ///
+
+    context.trace(`Validating the '${propertyAssertionString}' property assertion's property relation...`);
+
+    const propertyRelation = this.propertyRelation.validate(context);
+
+    if (propertyRelation !== null) {
+      propertyRelationValidates = true;
+    }
+
+    if (propertyRelationValidates) {
+      context.debug(`...validated the '${propertyAssertionString}' property assertion's property relation.`);
+    }
+
+    return propertyRelationValidates;
+  }
+
   assign(context) {
     const stated = context.isStated();
 

package/src/element/assertion/satisfies.js

@@ -79,12 +79,20 @@ export default define(class SatisfiesAssertion extends Assertion {
   validateSignature(context) {
     let signatureValidates = false;
 
+    const satisfiesAssertionString = this.getString(); ///
+
+    context.trace(`Validating the '${satisfiesAssertionString}' satisfies assertion's signature...`);
+
     const signature = this.signature.validate(context);
 
     if (signature !== null) {
       signatureValidates = true;
     }
 
+    if (signatureValidates) {
+      context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertion's signature.`);
+    }
+
     return signatureValidates;
   }
 

package/src/element/assertion/type.js

@@ -121,9 +121,9 @@ export default define(class TypeAssertion extends Assertion {
       let validatesForwards = false;
 
       const termType = term.getType(),
-            typeEqualToOrSubTypeOfTermType = this.type.isEqualToOrSubTypeOf(termType);
+            termTypeEqualToOrSuperTypeOfType = termType.isEqualToOrSuperTypeOf(this.type);
 
-      if (typeEqualToOrSubTypeOfTermType) {
+      if (termTypeEqualToOrSuperTypeOfType) {
         validatesForwards = true;
       }
 
@@ -137,7 +137,7 @@ export default define(class TypeAssertion extends Assertion {
     }
 
     if (validatesWhenStated) {
-      context.debug(`...verified the '${typeAssertionString}' stated type assertion.`);
+      context.debug(`...validated the '${typeAssertionString}' stated type assertion.`);
     }
 
     return validatesWhenStated;
@@ -157,9 +157,9 @@ export default define(class TypeAssertion extends Assertion {
             termTypeProvisional = termType.isProvisional();
 
       if (!termTypeProvisional) {
-        const typeEqualToOrSuperTypeOfTermType = this.type.isEqualToOrSuperTypeOf(termType);
+        const termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(this.type);
 
-        if (typeEqualToOrSuperTypeOfTermType) {
+        if (termTypeEqualToOrSubTypeOfType) {
           validatesForwards = true;
         }
       }
@@ -174,7 +174,7 @@ export default define(class TypeAssertion extends Assertion {
     }
 
     if (validatesWhenDerived) {
-      context.debug(`...verified the '${typeAssertionString}' derived type assertion.`);
+      context.debug(`...validated the '${typeAssertionString}' derived type assertion.`);
     }
 
     return validatesWhenDerived;