occam-verify-cli 1.0.906 → 1.0.911

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.`);
     }
 

package/src/element/signature.js

@@ -3,12 +3,10 @@
 import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
-import elements from "../elements";
-
 import { define } from "../elements";
 import { instantiateSignature } from "../process/instantiate";
 import { termsFromSignatureNode } from "../utilities/element";
-import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
+import { attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
 
 const { match, compare, correlate } = arrayUtilities;
 
@@ -30,6 +28,27 @@ export default define(class Signature extends Element {
     return signatureNode;
   }
 
+  getLength() {
+    const termsLength = this.terms.length,
+          length = termsLength; ///
+
+    return length;
+  }
+
+  getTerm(index) {
+    const term = this.terms[index];
+
+    return term;
+  }
+
+  findValidSignature(context) {
+    const signatureNode = this.getSignatureNode(),
+          signature = context.findSignatureBySignatureNode(signatureNode),
+          validSignature = signature;  ///
+
+    return validSignature;
+  }
+
   verify(context) {
     let verifies = false;
 
@@ -50,12 +69,60 @@ export default define(class Signature extends Element {
     }, context);
 
     if (verifies) {
-      context.debug(`...verified the '${signatureString}' signature.`);
+      context.debug(`...validated the '${signatureString}' signature.`);
     }
 
     return verifies;
   }
 
+  validate(context) {
+    let signature = null;
+
+    const signatureString = this.getString();  ///
+
+    context.trace(`Validating the '${signatureString}' signature...`);
+
+    let validates = false;
+
+    const validSignature = this.findValidSignature(context);
+
+    if (validSignature) {
+      signature = validSignature;  ///
+
+      context.debug(`...the '${signatureString}' signature is already valid.`);
+    } else {
+      const specificContext = context;  ///
+
+      context = this.getContext();
+
+      attempt((context) => {
+        const termsValidate = this.validateTerms(context);
+
+        if (termsValidate !== null) {
+          validates = true;
+        }
+
+        if (validates) {
+          this.commit(context);
+        }
+      }, context);
+
+      context = specificContext;  ///
+
+      if (validates) {
+        signature = this; ///
+
+        context.addSignature(signature);
+      }
+    }
+
+    if (validates) {
+      context.debug(`...validated the '${signatureString}' signature.`);
+    }
+
+    return signature;
+  }
+
   validateTerms(context) {
     let termsValidate;
 
@@ -90,40 +157,54 @@ export default define(class Signature extends Element {
     return termsValidate
   }
 
-  compareSignature(signature, substitutions, generalContext, specificContext) {
-    const terms = signature.getTerms(),
-          termsA = this.terms,  ///
-          termsB = terms, ///
-          matches = match(termsA, termsB, (termA, termB) => {
-            const { Variable } = elements,
-                  term = termB, ///
-                  context = generalContext, ///
-                  variable = Variable.fromTerm(term, context);
-
-            if (variable !== null) {
-              const term = termA, ///
-                    termType = term.getType(),
-                    variableType = variable.getType(),
-                    termTypeEqualToOrSubTypeOfVariableType = termType.isEqualToOrSubTypeOf(variableType);
-
-              if (termTypeEqualToOrSubTypeOfVariableType) {
-                debugger
-
-                // synthetically((context) => {
-                //   const { TermSubstitution } = elements;
-                //
-                //   TermSubstitution.fromTermAndVariable(term, variable, context);
-
-                //  validates...
-                // });
-
-                return true;
-              }
-            }
-          }),
-          comparesToSignature = matches; ///
+  unifySignature(signature, context) {
+    let signatureUnifies = false;
+
+    const generalSignature = this,
+          specificSignature = signature,  ///
+          generalSignatureString = generalSignature.getString(),
+          specificSignatureString = specificSignature.getString();
+
+    context.trace(`Unifying the '${specificSignatureString}' signature with the '${generalSignatureString}' signature...`);
+
+    context = specificSignature.getContext();
+
+    const specificContext = context;  ///
+
+    context = this.getContext();
+
+    const generalContext = context; ///
+
+    context = specificContext;  ///
+
+    reconcile((specificContext) => {
+      const generalSignatureTerms = generalSignature.getTerms(),
+            specificSignatureTerms = specificSignature.getTerms(),
+            generalTerms = generalSignatureTerms,  ///
+            specificTerms = specificSignatureTerms; ///
+
+      signatureUnifies = match(generalTerms, specificTerms, (generalTerm, specificTerm) => {
+        let termUnifies;
+
+        reconcile((specificContext) => {
+          termUnifies = generalTerm.unifyTerm(specificTerm, generalContext, specificContext);
+
+          if (termUnifies) {
+            specificContext.commit();
+          }
+        }, specificContext);
+
+        if (termUnifies) {
+          return true;
+        }
+      });
+    }, specificContext);
+
+    if (signatureUnifies) {
+      context.debug(`...unified the '${specificSignatureString}' signature with the '${generalSignatureString}' signature.`);
+    }
 
-    return comparesToSignature;
+    return signatureUnifies;
   }
 
   compareSubstitutions(substitutions, context) {

package/src/element/statement.js

@@ -192,14 +192,18 @@ export default define(class Statement extends Element {
 
     context.trace(`Validating the '${statementString}' statement...`);
 
+    let validates;
+
     const validStatement = this.findValidStatment(context);
 
     if (validStatement !== null) {
+      validates = true;
+
       statement = validStatement; ///
 
       context.debug(`...the '${statementString}' statement is already valid.`);
     } else {
-      const validates = validateStatements.some((validateStatement) => {
+      validates = validateStatements.some((validateStatement) => {
         const statement = this, ///
               statementValidates = validateStatement(statement, context);
 
@@ -212,11 +216,13 @@ export default define(class Statement extends Element {
         statement = this; ///
 
         context.addStatement(statement);
-
-        context.debug(`...validated the '${statementString}' statement.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${statementString}' statement.`);
+    }
+
     return statement;
   }
 

package/src/element/subproof.js

@@ -112,15 +112,15 @@ export default define(class Subproof extends Element {
     return subDerivationVerifies;
   }
 
-  unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
-    let unifiesWithSatisfiesAssertion = false;
+  unifyWithSignatureAssertion(signatureAssertion, context) {
+    let unifiesWithSignatureAssertion = false;
 
     const subproofString = this.getString(), ///
-          satisfiesAssertionString = satisfiesAssertion.getString();
+          signatureAssertionString = signatureAssertion.getString();
 
-    context.trace(`Unifying the '${subproofString}' subproof with the '${satisfiesAssertionString}' satisfies assertion...`)
+    context.trace(`Unifying the '${subproofString}' subproof with the '${signatureAssertionString}' signature assertion...`)
 
-    const reference = satisfiesAssertion.getReference(),
+    const reference = signatureAssertion.getReference(),
           axiom = context.findAxiomByReference(reference);
 
     if (axiom !== null) {
@@ -131,20 +131,20 @@ export default define(class Subproof extends Element {
               statementUnifies = axiom.unifySubproof(subproof, context);
 
         if (statementUnifies) {
-          const substitutionsCompare = satisfiesAssertion.compareSubstitutions(substitutions, context);
+          const substitutionsCompare = signatureAssertion.compareSubstitutions(substitutions, context);
 
           if (substitutionsCompare) {
-            unifiesWithSatisfiesAssertion = true;
+            unifiesWithSignatureAssertion = true;
           }
         }
       }
     }
 
-    if (unifiesWithSatisfiesAssertion) {
-      context.debug(`...unified the '${subproofString}' subproof with the '${satisfiesAssertionString}' satisfies assertion.`)
+    if (unifiesWithSignatureAssertion) {
+      context.debug(`...unified the '${subproofString}' subproof with the '${signatureAssertionString}' signature assertion.`)
     }
 
-    return unifiesWithSatisfiesAssertion;
+    return unifiesWithSignatureAssertion;
   }
 
   static name = "Subproof";

package/src/element/substitution/frame.js

@@ -82,6 +82,8 @@ export default define(class FrameSubstitution extends Substitution {
     const validSubstitution = this.findValidSubstitution(context);
 
     if (validSubstitution) {
+      validates = true;
+
       frameSubstitution = validSubstitution;  ///
 
       context.debug(`...the '${frameSubstitutionString}' frame substitution is already valid.`);
@@ -104,15 +106,17 @@ export default define(class FrameSubstitution extends Substitution {
           this.commit(generalContext, specificContext);
         }
       }, generalContext, specificContext);
-    }
 
-    if (validates) {
-      const substitution = this;  ///
+      if (validates) {
+        const substitution = this;  ///
 
-      frameSubstitution = substitution; ///
+        frameSubstitution = substitution; ///
 
-      context.addSubstitution(substitution);
+        context.addSubstitution(substitution);
+      }
+    }
 
+    if (validates) {
       context.debug(`...validated the '${frameSubstitutionString}' frame substitution.`);
     }
 

package/src/element/substitution/reference.js

@@ -99,6 +99,8 @@ export default define(class ReferenceSubstitution extends Substitution {
     const validSubstitution = this.findValidSubstitution(context);
 
     if (validSubstitution) {
+      validates = true;
+
       referenceSubstitution = validSubstitution;  ///
 
       context.debug(`...the '${referenceSubstitutionString}' reference substitution is already valid.`);
@@ -121,15 +123,17 @@ export default define(class ReferenceSubstitution extends Substitution {
           this.commit(generalContext, specificContext);
         }
       }, generalContext, specificContext);
-    }
 
-    if (validates) {
-      const substitution = this;  ///
+      if (validates) {
+        const substitution = this;  ///
 
-      referenceSubstitution = substitution;  ///
+        referenceSubstitution = substitution;  ///
 
-      context.addSubstitution(substitution);
+        context.addSubstitution(substitution);
+      }
+    }
 
+    if (validates) {
       context.debug(`...validated the '${referenceSubstitutionString}' reference substitution.`);
     }
 

package/src/element/substitution/statement.js

@@ -95,6 +95,8 @@ export default define(class StatementSubstitution extends Substitution {
     const validSubstitution = this.findValidSubstitution(context);
 
     if (validSubstitution) {
+      validates = true;
+
       statementSubstitution = validSubstitution;  ///
 
       context.debug(`...the '${statementSubstitutionString}' statement substitution is already valid.`);
@@ -121,15 +123,17 @@ export default define(class StatementSubstitution extends Substitution {
           this.commit(generalContext, specificContext);
         }
       }, generalContext, specificContext);
-    }
 
-    if (validates) {
-      const substitution = this;  ///
+      if (validates) {
+        const substitution = this;  ///
 
-      statementSubstitution = substitution; ///
+        statementSubstitution = substitution; ///
 
-      context.addSubstitution(substitution);
+        context.addSubstitution(substitution);
+      }
+    }
 
+    if (validates) {
       context.debug(`...validated the '${statementSubstitutionString}' statement substitution.`);
     }
 

package/src/element/substitution/term.js

@@ -107,15 +107,17 @@ export default define(class TermSubstitution extends Substitution {
           this.commit(generalContext, specificContext);
         }
       }, generalContext, specificContext);
-    }
 
-    if (validates) {
-      const substitution = this;  ///
+      if (validates) {
+        const substitution = this;  ///
 
-      termSubstitution = substitution;  ///
+        termSubstitution = substitution;  ///
 
-      context.addSubstitution(substitution);
+        context.addSubstitution(substitution);
+      }
+    }
 
+    if (validates) {
       context.debug(`...validated the '${termSubstitutionString}' term substitution.`);
     }
 

package/src/element/term.js

@@ -8,6 +8,7 @@ import { instantiate } from "../utilities/context";
 import { validateTerms } from "../utilities/validation";
 import { instantiateTerm } from "../process/instantiate";
 import { variablesFromTerm } from "../utilities/equivalence";
+import { unifyTermIntrinsically } from "../process/unify";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 const { filter } = arrayUtilities;
@@ -172,21 +173,24 @@ export default define(class Term extends Element {
 
     context.trace(`Validating the '${termString}' term...`);
 
-    const validTerm = this.findValidTerm(context),
-          valid = (validTerm !== null);
+    let validates = false;
 
-    if (valid) {
-      term = validTerm; ///
+    const validTerm = this.findValidTerm(context);
 
-      context.debug(`...the '${termString}' term is already valid.`);
+    if (validTerm !== null) {
+      term = validTerm; ///
 
       const validatesForward = validateForwards(term);
 
-      if (!validatesForward) {
+      if (validatesForward) {
+        validates = true;
+
+        context.debug(`...the '${termString}' term is already valid.`);
+      } else {
         term = null;
       }
     } else {
-      const validates = validateTerms.some((validateTerm) => {  ///
+      validates = validateTerms.some((validateTerm) => {  ///
         const term = this,  ///
               termValidates = validateTerm(term, context, validateForwards);
 
@@ -199,11 +203,13 @@ export default define(class Term extends Element {
         term = this;  ///
 
         context.addTerm(term);
-
-        context.debug(`...validated the '${termString}' term.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${termString}' term.`);
+    }
+
     return term;
   }
 
@@ -241,6 +247,30 @@ export default define(class Term extends Element {
     return term;
   }
 
+  unifyTerm(term, generalContext, specificContext) {
+    let termUnifies = false;
+
+    const context = specificContext,  ///
+          generalTerm = this,
+          specificTerm = term,
+          generalTermString = generalTerm.getString(),
+          specifixTermString = specificTerm.getString();
+
+    context.trace(`Unifying the '${specifixTermString}' term with the '${generalTermString}' term...`);
+
+    const termUnifiesIntrinsically = unifyTermIntrinsically(generalTerm, specificTerm, generalContext, specificContext);
+
+    if (termUnifiesIntrinsically) {
+      termUnifies = true;
+    }
+
+    if (termUnifies) {
+      context.debug(`...unified the '${specifixTermString}' term with the '${generalTermString}' term.`);
+    }
+
+    return termUnifies;
+  }
+
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
           string = this.getString(), ///

package/src/element/topLevelAssertion/axiom.js

@@ -23,32 +23,6 @@ export default define(class Axiom extends TopLevelAssertion {
     return satisfiable;
   }
 
-  compareSignature(signature, context) {
-    let comparesToSignature = false;
-
-    const satisfiable = this.isSatisfiable();
-
-    if (satisfiable) {
-      const signatureA = signature; ///
-
-      signature = this.getSignature()
-
-      const signatureB = signature, ///
-            specificContext = context;  ///
-
-      context = this.getContext();
-
-      const generalContext = context,  ///
-            signatureAComparesToSignatureB = signatureA.compareSignature(signatureB, generalContext, specificContext);
-
-      if (signatureAComparesToSignatureB) {
-        comparesToSignature = true;
-      }
-    }
-
-    return comparesToSignature;
-  }
-
   async verify(context) {
     let verifies;
 
@@ -242,6 +216,29 @@ export default define(class Axiom extends TopLevelAssertion {
     return lastStepUnifies;
   }
 
+  unifySignature(signature, context) {
+    let signatureUnifies;
+
+    const axiomString = this.getString(), ///
+          signatureString = signature.getString();
+
+    context.trace(`Unifying the '${signatureString}' signature with the '${axiomString}' axiom...`);
+
+    const specificSignature = signature;  ///
+
+    signature = this.getSignature();
+
+    const generalSignature = signature; ///
+
+    signatureUnifies = generalSignature.unifySignature(specificSignature, context);
+
+    if (signatureUnifies) {
+      context.debug(`...unified the '${signatureString}' signature with the '${axiomString}' axiom.`);
+    }
+
+    return signatureUnifies;
+  }
+
   unifyTopLevelAssertion(topLevelAssertion, context) {
     let topLevelAssertionUnifies = false;
 

package/src/element/variable.js

@@ -89,14 +89,14 @@ export default define(class Variable extends Element {
 
       this.type = type;
 
+      variable = this;
+
       validates = true;
     } else {
       context.debug(`The '${variableString}' variable is not present.`);
     }
 
     if (validates) {
-      variable = this;  ///
-
       context.debug(`...validated the '${variableString}' variable.`);
     }
 

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

@@ -4,7 +4,7 @@ import AssertionNode from "../../node/assertion";
 
 import { SIGNATURE_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
 
-export default class SatisfiesAssertionNode extends AssertionNode {
+export default class SignatureAssertionNode extends AssertionNode {
   getSignatureNode() {
     const ruleName = SIGNATURE_RULE_NAME,
           signatureNode = this.getNodeByRuleName(ruleName);
@@ -19,5 +19,5 @@ export default class SatisfiesAssertionNode extends AssertionNode {
     return metavariableNode;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return AssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(SatisfiesAssertionNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return AssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(SignatureAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/qualification.js

@@ -2,7 +2,7 @@
 
 import { NonTerminalNode } from "occam-languages";
 
-import { REFERENCE_RULE_NAME, SATISFIES_ASSERTION_RULE_NAME } from "../ruleNames";
+import { REFERENCE_RULE_NAME, SIGNATURE_ASSERTION_RULE_NAME } from "../ruleNames";
 
 export default class QualificationNode extends NonTerminalNode {
   getReferenceNode() {
@@ -13,7 +13,7 @@ export default class QualificationNode extends NonTerminalNode {
   }
 
   getSatisfiedAssertionNode() {
-    const ruleName = SATISFIES_ASSERTION_RULE_NAME,
+    const ruleName = SIGNATURE_ASSERTION_RULE_NAME,
           satisfiedAssertionNode = this.getNodeByRuleName(ruleName);
 
     return satisfiedAssertionNode;