occam-verify-cli 1.0.906 → 1.0.911

package/src/element/assertion/{satisfies.js → signature.js}

@@ -4,10 +4,10 @@ import Assertion from "../assertion";
 
 import { define } from "../../elements";
 import { instantiate } from "../../utilities/context";
-import { instantiateSatisfiesAssertion } from "../../process/instantiate";
-import { signatureFromJSatisfiesAssertionNode, referenceFromJSatisfiesAssertionNode, satisfiesAssertionFromStatementNode } from "../../utilities/element";
+import { instantiateSignatureAssertion } from "../../process/instantiate";
+import { signatureFromJSignatureAssertionNode, referenceFromJSignatureAssertionNode, signatureAssertionFromStatementNode } from "../../utilities/element";
 
-export default define(class SatisfiesAssertion extends Assertion {
+export default define(class SignatureAssertion extends Assertion {
   constructor(context, string, node, lineIndex, signature, reference) {
     super(context, string, node, lineIndex);
 
@@ -23,11 +23,11 @@ export default define(class SatisfiesAssertion extends Assertion {
     return this.reference;
   }
 
-  getSatisfiesAssertionNode() {
+  getSignatureAssertionNode() {
     const node = this.getNode(),
-          satisfiesAssertionNode = node;  ///
+          signatureAssertionNode = node;  ///
 
-    return satisfiesAssertionNode;
+    return signatureAssertionNode;
   }
 
   compareSubstitutions(substitutions, context) { return this.signature.compareSubstitutions(substitutions, context); }
@@ -35,21 +35,23 @@ export default define(class SatisfiesAssertion extends Assertion {
   correlateSubstitutions(substitutions, context) { return this.signature.correlateSubstitutions(substitutions, context); }
 
   validate(context) {
-    let satisfiesAssertion = null;
+    let signatureAssertion = null;
 
-    const satisfiesAssertionString = this.getString(); ///
+    const signatureAssertionString = this.getString(); ///
 
-    context.trace(`Validating the '${satisfiesAssertionString}' satisfies assertion...`);
+    context.trace(`Validating the '${signatureAssertionString}' signature assertion...`);
+
+    let validates = true;
 
     const validAssertion = this.findValidAssertion(context);
 
     if (validAssertion) {
-      satisfiesAssertion = validAssertion; ///
+      validates = true;
 
-      context.debug(`...the '${satisfiesAssertionString}' satisfies satisfiesAssertion is already valid.`);
-    } else {
-      let validates = true;
+      signatureAssertion = validAssertion; ///
 
+      context.debug(`...the '${signatureAssertionString}' signature assertion is already valid.`);
+    } else {
       const signatureVerifies = this.validateSignature(context);
 
       if (signatureVerifies) {
@@ -65,32 +67,36 @@ export default define(class SatisfiesAssertion extends Assertion {
       if (validates) {
         const assertion = this; ///
 
-        satisfiesAssertion = assertion; ///
-
-        context.addAssertion(satisfiesAssertion);
+        signatureAssertion = assertion; ///
 
-        context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertion.`);
+        context.addAssertion(signatureAssertion);
       }
     }
 
-    return satisfiesAssertion;
+    if (validates) {
+      context.debug(`...validated the '${signatureAssertionString}' signature assertion.`);
+    }
+
+    return signatureAssertion;
   }
 
   validateSignature(context) {
     let signatureValidates = false;
 
-    const satisfiesAssertionString = this.getString(); ///
+    const signatureAssertionString = this.getString(); ///
 
-    context.trace(`Validating the '${satisfiesAssertionString}' satisfies assertion's signature...`);
+    context.trace(`Validating the '${signatureAssertionString}' signature assertion's signature...`);
 
     const signature = this.signature.validate(context);
 
     if (signature !== null) {
+      this.signature = signature;
+
       signatureValidates = true;
     }
 
     if (signatureValidates) {
-      context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertion's signature.`);
+      context.debug(`...validated the '${signatureAssertionString}' signature assertion's signature.`);
     }
 
     return signatureValidates;
@@ -99,22 +105,41 @@ export default define(class SatisfiesAssertion extends Assertion {
   validateReference(context) {
     let referenceVerifies = false;
 
-    const satisfiesAssertionString = this.getString();  ///
+    const signatureAssertionString = this.getString();  ///
+
+    context.trace(`Validating the '${signatureAssertionString}' signature assertion's reference...`);
 
-    context.trace(`Validating the '${satisfiesAssertionString}' satisfies assertino's reference...`);
+    const reference = this.reference.validate(context);
 
-    const axiom = context.findAxiomByReference(this.reference);
+    if (reference !== null) {
+      const axiom = context.findAxiomByReference(reference);
+
+      if (axiom !== null) {
+        const satisfiable = axiom.isSatisfiable();
+
+        if (satisfiable) {
+          const signatureUnifies = axiom.unifySignature(this.signature, context);
+
+          if (signatureUnifies) {
+            this.reference = reference;
+
+            referenceVerifies = true;
+          }
+        } else {
+          const axiomString = axiom.getString();
+
+          context.debug(`The '${axiomString}' axiom is not satisfiable.`);
+        }
 
-    if (axiom !== null) {
-      const axiomSatisfiable = axiom.isSatisfiable();
+      } else {
+        const referencdString = reference.getString();
 
-      if (axiomSatisfiable) {
-        referenceVerifies = true;
+        context.debug(`There is no axiom for the '${referencdString}' reference.`);
       }
     }
 
     if (referenceVerifies) {
-      context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertino's reference.`);
+      context.debug(`...validated the '${signatureAssertionString}' signature assertion's reference.`);
     }
 
     return referenceVerifies;
@@ -124,9 +149,9 @@ export default define(class SatisfiesAssertion extends Assertion {
     let stepAndSubproofOrProofAssertionsUnify = false;
 
     const steptString = step.getString(),
-          satisfiesAssertionString = this.getString(); ///
+          signatureAssertionString = this.getString(); ///
 
-    context.trace(`Unifying the '${steptString}' step with the '${satisfiesAssertionString}' satisfies assertion...`);
+    context.trace(`Unifying the '${steptString}' step with the '${signatureAssertionString}' signature assertion...`);
 
     this.signature.validate(context);
 
@@ -158,47 +183,47 @@ export default define(class SatisfiesAssertion extends Assertion {
     }
 
     if (stepAndSubproofOrProofAssertionsUnify) {
-      context.debug(`...unified the '${steptString}' step with the '${satisfiesAssertionString}' satisfies assertion.`);
+      context.debug(`...unified the '${steptString}' step with the '${signatureAssertionString}' signature assertion.`);
     }
 
     return stepAndSubproofOrProofAssertionsUnify;
   }
 
-  static name = "SatisfiesAssertion";
+  static name = "SignatureAssertion";
 
   static fromJSON(json, context) {
-    let satisfiesAssertion = null;
+    let signatureAssertion = null;
 
     const { name } = json;
 
     if (this.name === name) {
       instantiate((context) => {
         const { string, lineIndex } = json,
-              definedAssertionNode = instantiateSatisfiesAssertion(string, context),
+              definedAssertionNode = instantiateSignatureAssertion(string, context),
               node = definedAssertionNode,  ///
-              signature = signatureFromJSatisfiesAssertionNode(definedAssertionNode, context),
-              reference = referenceFromJSatisfiesAssertionNode(definedAssertionNode, context);
+              signature = signatureFromJSignatureAssertionNode(definedAssertionNode, context),
+              reference = referenceFromJSignatureAssertionNode(definedAssertionNode, context);
 
         context = null;
 
-        satisfiesAssertion = new SatisfiesAssertion(context, string, node, lineIndex, signature, reference);
+        signatureAssertion = new SignatureAssertion(context, string, node, lineIndex, signature, reference);
       }, context);
     }
 
-    return satisfiesAssertion;
+    return signatureAssertion;
   }
 
   static fromStep(step, context) {
     const statementNode = step.getStatementNode(),
-      satisfiesAssertion = satisfiesAssertionFromStatementNode(statementNode, context);
+          signatureAssertion = signatureAssertionFromStatementNode(statementNode, context);
 
-    return satisfiesAssertion;
+    return signatureAssertion;
   }
 
   static fromStatement(statement, context) {
     const statementNode = statement.getNode(),
-          satisfiesAssertion = satisfiesAssertionFromStatementNode(statementNode, context);
+          signatureAssertion = signatureAssertionFromStatementNode(statementNode, context);
 
-    return satisfiesAssertion;
+    return signatureAssertion;
   }
 });

package/src/element/assertion/subproof.js

@@ -57,6 +57,8 @@ export default define(class SubproofAssertion extends Assertion {
 
     context.trace(`Validating the '${subproofAssertionString}' subproof assertion...`);
 
+    let validates = false;
+
     const validAssertion = this.findValidAssertion(context);
 
     if (validAssertion) {
@@ -64,8 +66,6 @@ export default define(class SubproofAssertion extends Assertion {
 
       context.debug(`...the '${subproofAssertionString}' subproof assertion is already valid.`);
     } else {
-      let validates = false;
-
       const statementsValidate = this.validateStatements(context);
 
       if (statementsValidate) {
@@ -78,11 +78,13 @@ export default define(class SubproofAssertion extends Assertion {
         subproofAssertion = assertion;  ///
 
         context.addAssertion(assertion);
-
-        context.debug(`...validated the '${subproofAssertionString}' subproof assertion.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${subproofAssertionString}' subproof assertion.`);
+    }
+
     return subproofAssertion;
   }
 

package/src/element/assertion/type.js

@@ -39,15 +39,17 @@ export default define(class TypeAssertion extends Assertion {
 
     context.trace(`Validating the '${typeAssertionString}' type assertion...`);
 
+    let validates = false;
+
     const validAssertion = this.findValidAssertion(context);
 
     if (validAssertion) {
+      validates = true;
+
       typeAssertion = validAssertion; ///
 
       context.debug(`...the '${typeAssertionString}' type assertion is already valid.`);
     } else {
-      let validates = false;
-
       const typeValidates = this.validateType(context);
 
       if (typeValidates) {
@@ -75,11 +77,13 @@ export default define(class TypeAssertion extends Assertion {
         this.assign(context);
 
         context.addAssertion(assertion);
-
-        context.debug(`...verified the '${typeAssertionString}' type assertion.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...verified the '${typeAssertionString}' type assertion.`);
+    }
+
     return typeAssertion;
   }
 

package/src/element/assumption/metaLevel.js

@@ -105,13 +105,15 @@ export default define(class MetaLevelAssumption extends Element {
           this.commit(context);
         }
       }, context);
-    }
 
-    if (validates) {
-      metaLevelAssumption = this;  ///
+      if (validates) {
+        metaLevelAssumption = this;  ///
 
-      context.addMetaLevelAssumption(metaLevelAssumption);
+        context.addMetaLevelAssumption(metaLevelAssumption);
+      }
+    }
 
+    if (validates) {
       context.debug(`...validated the '${metaLevelAssumptionString}' meta-level assumption.`);
     }
 

package/src/element/assumption.js

@@ -64,15 +64,17 @@ export default define(class Assumption extends Element {
 
     context.trace(`Validating the '${assumptionString}' assumption...`);
 
+    let validates = false;
+
     const validAssumption = this.findValidAssumption(context);
 
     if (validAssumption) {
+      validates = true;
+
       assumption = validAssumption; ///
 
       context.debug(`...the '${assumptionString}' assumption is already valid.`);
     } else {
-      let validates = false;
-
       const statementValidates = this.validateStatement(context);
 
       if (statementValidates) {
@@ -100,11 +102,13 @@ export default define(class Assumption extends Element {
         assumption = this;  ///
 
         context.addAssumption(assumption);
-
-        context.debug(`...validated the '${assumptionString}' assumption.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${assumptionString}' assumption.`);
+    }
+
     return assumption;
   }
 

package/src/element/equality.js

@@ -123,15 +123,17 @@ export default define(class Equality extends Element {
 
     context.trace(`Validating the '${equalityString}' equality...`);
 
+    let validates = false;
+
     const validEquality = this.findValidEquality(context);
 
     if (validEquality !== null) {
+      validates = true;
+
       equality = validEquality; ///
 
       context.debug(`...the '${equalityString}' equality is already valid.`);
     } else {
-      let validates = false;
-
       const termsValidate = this.validateTerms(context);
 
       if (termsValidate) {
@@ -157,11 +159,13 @@ export default define(class Equality extends Element {
         this.assign(context);
 
         context.addEquality(equality);
-
-        context.debug(`...validated the '${equalityString}' equality.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${equalityString}' equality.`);
+    }
+
     return equality;
   }
 

package/src/element/frame.js

@@ -120,16 +120,17 @@ export default define(class Frame extends Element {
 
     context.trace(`Validating the '${frameString}' frame...`);
 
-    const validFrame = this.findValidFrame(context),
-          valid = (validFrame !== null);
+    let validates = false;
+
+    const validFrame = this.findValidFrame(context);
+
+    if (validFrame !== null) {
+      validates = true;
 
-    if (valid) {
       frame = validFrame; ///
 
       context.debug(`...the '${frameString}' frame is already valid.`);
     } else {
-      let validates = false;
-
       const metavariableValidates = this.validatMetavariable(context);
 
       if (metavariableValidates) {
@@ -157,11 +158,13 @@ export default define(class Frame extends Element {
         frame = this; ///
 
         context.addFrame(frame);
-
-        context.debug(`...validated the '${frameString}' frame.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${frameString}' frame.`);
+    }
+
     return frame;
   }
 

package/src/element/judgement.js

@@ -81,15 +81,17 @@ export default define(class Judgement extends Element {
 
     context.trace(`Validating the '${judgementString}' judgement...`);
 
+    let validates = false;
+
     const validJudgement = this.findValidJudgement(context);
 
     if (validJudgement !== null) {
+      validates = true;
+
       judgement = validJudgement; ///
 
       context.debug(`...the '${judgementString}' judgement is already valid.`);
     } else {
-      let validates = false;
-
       const frameValidates = this.validateFrame(context);
 
       if (frameValidates) {
@@ -119,11 +121,13 @@ export default define(class Judgement extends Element {
         this.assign(context);
 
         context.addJudgement(judgement);
-
-        context.debug(`...validated the '${judgementString}' judgement.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${judgementString}' judgement.`);
+    }
+
     return judgement;
   }
 

package/src/element/metavariable.js

@@ -182,16 +182,17 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Validating the '${metavariableString}' metavariable...`);
 
-    const validMetavariable = this.findValidMetavariable(context),
-          valid = (validMetavariable !== null);
+    let validates = false;
+
+    const validMetavariable = this.findValidMetavariable(context);
+
+    if (validMetavariable !== null) {
+      validates = true;
 
-    if (valid) {
       metavariable = validMetavariable; ///
 
       context.debug(`...the '${metavariableString}' metavariable is already valid.`);
     } else {
-      let validates = false;
-
       const nameValidates = this.validateName(strict, context);
 
       if (nameValidates) {
@@ -214,11 +215,13 @@ export default define(class Metavariable extends Element {
         if (declared) {
           context.addMetavariable(metavariable);
         }
-
-        context.debug(`...validated the '${metavariableString}' metavariable.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${metavariableString}' metavariable.`);
+    }
+
     return metavariable;
   }
 

package/src/element/proofAssertion/step.js

@@ -14,19 +14,19 @@ const { asyncSome } = asynchronousUtilities,
       { backwardsSome } = arrayUtilities;
 
 export default define(class Step extends ProofAssertion {
-  constructor(context, string, node, lineIndex, statement, reference, satisfiesAssertion) {
+  constructor(context, string, node, lineIndex, statement, reference, signatureAssertion) {
     super(context, string, node, lineIndex, statement);
 
     this.reference = reference;
-    this.satisfiesAssertion = satisfiesAssertion;
+    this.signatureAssertion = signatureAssertion;
   }
 
   getReference() {
     return this.reference;
   }
 
-  getSatisfiesAssertion() {
-    return this.satisfiesAssertion;
+  getSignatureAssertion() {
+    return this.signatureAssertion;
   }
 
   getStepNode() {
@@ -44,7 +44,7 @@ export default define(class Step extends ProofAssertion {
   }
 
   isSatisfied() {
-    const satisfied = (this.satisfiesAssertion !== null);
+    const satisfied = (this.signatureAssertion !== null);
 
     return satisfied;
   }
@@ -143,9 +143,9 @@ export default define(class Step extends ProofAssertion {
           const referenceValidates = this.validateReference(context);
 
           if (referenceValidates) {
-            const satisfiesAssertionValidates = this.validateSatisfiesAssertion(context);
+            const signatureAssertionValidates = this.validateSignatureAssertion(context);
 
-            if (satisfiesAssertionValidates) {
+            if (signatureAssertionValidates) {
               validates = true;
             }
           }
@@ -211,27 +211,27 @@ export default define(class Step extends ProofAssertion {
     return statementValidates;
   }
 
-  validateSatisfiesAssertion(context) {
-    let satisfiesAssertionValidates = true;  ///
+  validateSignatureAssertion(context) {
+    let signatureAssertionValidates = true;  ///
 
-    if (this.satisfiesAssertion !== null) {
+    if (this.signatureAssertion !== null) {
       const stepString = this.getString(),  ///
-            satisfiesAssertionString = this.satisfiesAssertion.getString();
+            signatureAssertionString = this.signatureAssertion.getString();
 
-      context.trace(`Validating the '${stepString}' step's '${satisfiesAssertionString}' satisfies assertion... `);
+      context.trace(`Validating the '${stepString}' step's '${signatureAssertionString}' signature assertion... `);
 
-      const satisfiesAssertion = this.satisfiesAssertion.validate(context);
+      const signatureAssertion = this.signatureAssertion.validate(context);
 
-      if (satisfiesAssertion === null) {
-        satisfiesAssertionValidates = false;
+      if (signatureAssertion === null) {
+        signatureAssertionValidates = false;
       }
 
-      if (satisfiesAssertionValidates) {
-        context.debug(`...validating the '${stepString}' step's '${satisfiesAssertionString}' satisfies assertion. `);
+      if (signatureAssertionValidates) {
+        context.debug(`...validating the '${stepString}' step's '${signatureAssertionString}' signature assertion. `);
       }
     }
 
-    return satisfiesAssertionValidates;
+    return signatureAssertionValidates;
   }
 
   async unify(context) {
@@ -264,15 +264,15 @@ export default define(class Step extends ProofAssertion {
     return unifies;
   }
 
-  unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
-    let unifiesWithSatisfiesAssertion = false;
+  unifyWithSignatureAssertion(signatureAssertion, context) {
+    let unifiesWithSignatureAssertion = false;
 
     const stepString = this.getString(), ///
-          satisfiesAssertionString = satisfiesAssertion.getString();
+          signatureAssertionString = signatureAssertion.getString();
 
-    context.trace(`Unifying the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion...`);
+    context.trace(`Unifying the '${stepString}' step with the '${signatureAssertionString}' signature assertion...`);
 
-    const reference = satisfiesAssertion.getReference(),
+    const reference = signatureAssertion.getReference(),
           axiom = context.findAxiomByReference(reference);
 
     if (axiom !== null) {
@@ -280,19 +280,19 @@ export default define(class Step extends ProofAssertion {
             stepUnifies = axiom.unifyStep(step, context);
 
       if (stepUnifies) {
-        const substitutionsCompare = satisfiesAssertion.compareSubstitutions(context);
+        const substitutionsCompare = signatureAssertion.compareSubstitutions(context);
 
         if (substitutionsCompare) {
-          unifiesWithSatisfiesAssertion = true;
+          unifiesWithSignatureAssertion = true;
         }
       }
     }
 
-    if (unifiesWithSatisfiesAssertion) {
-      context.debug(`...unified the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion.`);
+    if (unifiesWithSignatureAssertion) {
+      context.debug(`...unified the '${stepString}' step with the '${signatureAssertionString}' signature assertion.`);
     }
 
-    return unifiesWithSatisfiesAssertion;
+    return unifiesWithSignatureAssertion;
   }
 
   static name = "Step";

package/src/element/property.js

@@ -129,27 +129,31 @@ export default define(class Property extends Element {
 
     context.trace(`Validating the '${propertyString}' property...`);
 
+    let validates = false;
+
     const validProperty = this.findValidProperty(context);
 
-    if (validProperty) {
+    if (validProperty !== null) {
       property = validProperty; ///
 
-      context.debug(`...the '${propertyString}' property is already valid.`);
-
       const validatesForward = validateForwards(property);
 
-      if (!validatesForward) {
+      if (validatesForward) {
+        validates = true;
+
+        context.debug(`...the '${propertyString}' property is already valid.`);
+      } else {
         property = null;
       }
     } else {
-      let validates = false;
-
       property = this;  ///
 
       const validatesForward = validateForwards(property);
 
       if (validatesForward) {
         validates = true;
+      } else {
+        property = null;
       }
 
       if (validates) {
@@ -159,6 +163,10 @@ export default define(class Property extends Element {
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${propertyString}' property.`);
+    }
+
     return property;
   }