occam-verify-cli 1.0.905 → 1.0.910

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.905",
+  "version": "1.0.910",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,12 +12,12 @@
   "dependencies": {
     "argumentative": "^2.0.47",
     "necessary": "^17.1.7",
-    "occam-furtle": "^3.0.192",
+    "occam-furtle": "^3.0.193",
     "occam-grammars": "^1.3.520",
-    "occam-languages": "^0.0.196",
+    "occam-languages": "^0.0.197",
     "occam-lexers": "^23.1.44",
     "occam-model": "^1.0.505",
-    "occam-nominal": "^1.0.100",
+    "occam-nominal": "^1.0.101",
     "occam-parsers": "^23.1.50",
     "occam-server": "^7.0.6"
   },

package/src/context.js

@@ -206,6 +206,13 @@ export default class Context extends ContextBase {
     return rule;
   }
 
+  findAxiomByReference(reference) {
+    const context = this.getContext(),
+          axiom = context.findAxiomByReference(reference);
+
+    return axiom;
+  }
+
   findTopLevelAssertionByReference(reference) {
     const context = this.getContext(),
           topLevelAssertion = context.findTopLevelAssertionByReference(reference);

package/src/element/assertion/contained.js

@@ -52,15 +52,17 @@ export default define(class ContainedAssertion extends Assertion {
 
     context.trace(`Validating the '${containedAssertionString}' contained assertion...`);
 
+    let validates = false;
+
     const validAssertion = this.findValidAssertion(context);
 
     if (validAssertion !== null) {
+      validates = true;
+
       containedAssertion = validAssertion;  ///
 
       context.debug(`...the '${containedAssertionString}' contained assertion is already valid.`);
     } else {
-      let validates = false;
-
       const termValidates = this.validateTerm(context),
             frameValidates = this.validateFrame(context),
             statementValidates = this.validateStatement(context)
@@ -88,11 +90,13 @@ export default define(class ContainedAssertion extends Assertion {
         containedAssertion = assertion;  ///
 
         context.addAssertion(assertion);
-
-        context.debug(`...validated the '${containedAssertionString}' contained assertion.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${containedAssertionString}' contained assertion.`);
+    }
+
     return containedAssertion;
   }
 

package/src/element/assertion/defined.js

@@ -44,15 +44,17 @@ export default define(class DefinedAssertion extends Assertion {
 
     context.trace(`Validating the '${definedAssertionString}' defined assertion...`);
 
+    let validates = false;
+
     const validAssertion = this.findValidAssertion(context);
 
     if (validAssertion !== null) {
+      validates = true;
+
       definedAssertion = validAssertion;  ///
 
       context.debug(`...the '${definedAssertionString}' defined definedAssertion is already valid.`);
     } else {
-      let validates = false;
-
       const termValidates = this.validateTerm(context),
             frameValidates = this.validateFrame(context);
 
@@ -79,11 +81,13 @@ export default define(class DefinedAssertion extends Assertion {
         definedAssertion = assertion; ///
 
         context.addAssertion(assertion);
-
-        context.debug(`...validated the '${definedAssertionString}' defined assertion.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${definedAssertionString}' defined assertion.`);
+    }
+
     return definedAssertion;
   }
 

package/src/element/assertion/property.js

@@ -66,15 +66,17 @@ export default define(class PropertyAssertion extends Assertion {
 
     context.trace(`Validating the '${propertyAssertionString}' property assertion...`);
 
+    let validates = false;
+
     const validAssertion = this.findValidAssertion(context);
 
     if (validAssertion) {
+      validates = true;
+
       propertyAssertion = validAssertion; ///
 
       context.debug(`...the '${propertyAssertionString}' property assertion is already valid.`);
     } else {
-      let validates = false;
-
       const propertyRelationVerifies = this.validatePropertyRelation(context);
 
       if (propertyRelationVerifies) {
@@ -106,11 +108,13 @@ export default define(class PropertyAssertion extends Assertion {
         this.assign(context);
 
         context.addAssertion(assertion);
-
-        context.debug(`...validated the '${propertyAssertionString}' property assertion.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${propertyAssertionString}' property assertion.`);
+    }
+
     return propertyAssertion;
   }
 

package/src/element/assertion/satisfies.js

@@ -41,15 +41,17 @@ export default define(class SatisfiesAssertion extends Assertion {
 
     context.trace(`Validating the '${satisfiesAssertionString}' satisfies assertion...`);
 
+    let validates = true;
+
     const validAssertion = this.findValidAssertion(context);
 
     if (validAssertion) {
+      validates = true;
+
       satisfiesAssertion = validAssertion; ///
 
       context.debug(`...the '${satisfiesAssertionString}' satisfies satisfiesAssertion is already valid.`);
     } else {
-      let validates = true;
-
       const signatureVerifies = this.validateSignature(context);
 
       if (signatureVerifies) {
@@ -68,11 +70,13 @@ export default define(class SatisfiesAssertion extends Assertion {
         satisfiesAssertion = assertion; ///
 
         context.addAssertion(satisfiesAssertion);
-
-        context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertion.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertion.`);
+    }
+
     return satisfiesAssertion;
   }
 
@@ -86,6 +90,8 @@ export default define(class SatisfiesAssertion extends Assertion {
     const signature = this.signature.validate(context);
 
     if (signature !== null) {
+      this.signature = signature;
+
       signatureValidates = true;
     }
 
@@ -103,13 +109,32 @@ export default define(class SatisfiesAssertion extends Assertion {
 
     context.trace(`Validating the '${satisfiesAssertionString}' satisfies assertino's reference...`);
 
-    const axiom = context.findAxiomByReference(this.reference);
+    const reference = this.reference.validate(context);
+
+    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.`);
       }
     }
 

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/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;
   }
 

package/src/element/propertyRelation.js

@@ -63,15 +63,17 @@ export default define(class PropertyRelation extends Element {
 
     context.trace(`Validating the '${propertyRelationString}' property relation...`);
 
+    let validates = false;
+
     const validPropertyRelation = this.findValidPropertyRelation(context);
 
     if (validPropertyRelation) {
+      validates = true;
+
       propertyRelation = validPropertyRelation; ///
 
       context.debug(`...the '${propertyRelationString}' property relation is already valid.`);
     } else {
-      let validates = false;
-
       const termValidates = this.validateTerm(context);
 
       if (termValidates) {
@@ -84,11 +86,13 @@ export default define(class PropertyRelation extends Element {
         propertyRelation = this; ///
 
         context.addPropertyRelation(propertyRelation);
-
-        context.debug(`...validated the '${propertyRelationString}' property relation.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${propertyRelationString}' property relation.`);
+    }
+
     return propertyRelation;
   }
 

package/src/element/reference.js

@@ -123,7 +123,9 @@ export default define(class Reference extends Element {
 
       context.debug(`...the '${referenceString}' reference is already valid.`);
     } else {
-      const context = this.getContext();
+      const specificContext = context;  ///
+
+      context = this.getContext();
 
       attempt((context) => {
         const metavariableValidates = this.validateMetavariable(context);
@@ -161,13 +163,17 @@ export default define(class Reference extends Element {
           this.commit(context);
         }
       }, context);
-    }
 
-    if (validates) {
-      reference = this;  ///
+      context = specificContext;  ///
 
-      context.addReference(reference);
+      if (validates) {
+        reference = this;  ///
 
+        context.addReference(reference);
+      }
+    }
+
+    if (validates) {
       context.debug(`...validated the '${referenceString}' reference.`);
     }