occam-verify-cli 1.0.764 → 1.0.776

package/src/element/equality.js

@@ -6,6 +6,7 @@ import { define } from "../elements";
 import { instantiate } from "../utilities/context";
 import { equateTerms } from "../process/equate";
 import { instantiateEquality } from "../process/instantiate";
+import { equalityFromStatementNode } from "../utilities/element";
 import { equalityAssignmentFromEquality, leftVariableAssignmentFromEquality, rightVariableAssignmentFromEquality } from "../process/assign";
 
 export default define(class Equality extends Element {
@@ -115,7 +116,7 @@ export default define(class Equality extends Element {
     return validEquality;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let equality = null;
 
     const equalityString = this.getString(); ///
@@ -134,6 +135,8 @@ export default define(class Equality extends Element {
       const termsValidate = this.validateTerms(context);
 
       if (termsValidate) {
+        const stated = context.isStated();
+
         let validatesWhenStated = false,
             validatesWhenDerived = false;
 
@@ -151,7 +154,7 @@ export default define(class Equality extends Element {
       if (validates) {
         equality = this;  ///
 
-        this.assign(stated, context);
+        this.assign(context);
 
         context.addEquality(equality);
 
@@ -243,29 +246,17 @@ export default define(class Equality extends Element {
     return validatesWhenDerived;
   }
 
-  assign(stated, context) {
+  assign(context) {
     const equality = this,  ///
           equalityAssignment = equalityAssignmentFromEquality(equality, context),
           leftVariableAssignment = leftVariableAssignmentFromEquality(equality, context),
           rightVariableAssignment = rightVariableAssignmentFromEquality(equality, context);
 
-    let assignment;
-
-    assignment = equalityAssignment; ///
-
-    context.addAssignment(assignment);
-
-    if (leftVariableAssignment !== null) {
-      assignment = leftVariableAssignment;  ///
-
-      context.addAssignment(assignment);
-    }
+    context.addAssignment(equalityAssignment);
 
-    if (rightVariableAssignment !== null) {
-      assignment = rightVariableAssignment;  ///
+    context.addAssignment(leftVariableAssignment);
 
-      context.addAssignment(assignment);
-    }
+    context.addAssignment(rightVariableAssignment);
   }
 
   static name = "Equality";
@@ -294,6 +285,13 @@ export default define(class Equality extends Element {
       return equality;
     }, context);
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          equality = equalityFromStatementNode(statementNode, context);
+
+    return equality;
+  }
 });
 
 function leftTermFromEqualityNode(equalityNode, context) {

package/src/element/equivalence.js

@@ -13,16 +13,29 @@ import { equivalenceFromEquivalenceNode } from "../utilities/element";
 const { compress } = arrayUtilities;
 
 export default define(class Equivalence extends Element {
-  constructor(context, string, node, terms) {
+  constructor(context, string, node, type, terms) {
     super(context, string, node);
 
+    this.type = type;
     this.terms = terms;
   }
 
+  getType() {
+    return this.type;
+  }
+
   getTerms() {
     return this.terms;
   }
 
+  setType(type) {
+    this.type = type;
+  }
+
+  setTerms(terms) {
+    this.terms = terms;
+  }
+
   getEquivalenceNode() {
     const node = this.getNode(),
           equivalenceNode = node; ///
@@ -30,26 +43,6 @@ export default define(class Equivalence extends Element {
     return equivalenceNode;
   }
 
-  getType() {
-    const type = this.terms.reduce((type, term) => {
-      const termType = term.getType();
-
-      if (type === null) {
-        type = termType;  ///
-      } else {
-        const termTypeSubTypeOfType = termType.isSubTypeOf(type);
-
-        if (termTypeSubTypeOfType) {
-          type = termType;  ///
-        }
-      }
-
-      return type;
-    }, null);
-
-    return type;
-  }
-
   getGroundedTerms(definedVariables, groundedTerms, context) {
     this.terms.forEach((term) => {
       const termGrounded = term.isGrounded(definedVariables, context);
@@ -133,20 +126,6 @@ export default define(class Equivalence extends Element {
     return implicitlyGrounded;
   }
 
-  compareTerm(term) {
-    const termA = term, ///
-          comparesToTerm = this.someTerm((term) => {
-            const termB = term, ///
-                  termAEqualToTermB = termA.isEqualTo(termB);
-
-            if (termAEqualToTermB) {
-              return true;
-            }
-          });
-
-    return comparesToTerm;
-  }
-
   matchTermNode(termNode) {
     termNode = stripBracketsFromTermNode(termNode); ///
 
@@ -173,36 +152,31 @@ export default define(class Equivalence extends Element {
     return termNodesMatch;
   }
 
-  matchVariableNode(variableNode) {
-    const variableNodeA = variableNode, ///
-          variableNodeMatches = this.someTerm((term) => {
-            const termNode = term.getNode(),
-                  singularVariableNode = termNode.getSingularVariableNode();
+  someTerm(callback) { return this.terms.some(callback); }
+
+  everyTerm(callback) { return this.terms.every(callback); }
 
-            if (singularVariableNode !== null) {
-              const variableNodeB = singularVariableNode, ///
-                    variableNodeAMatchesVariableNodeB = variableNodeA.match(variableNodeB);
+  compareTerm(term) {
+    const termA = term, ///
+          comparesToTerm = this.someTerm((term) => {
+            const termB = term, ///
+                  termAComparesToTermB = termA.compareTerm(termB);
 
-              if (variableNodeAMatchesVariableNodeB) {
-                return true;
-              }
+            if (termAComparesToTermB) {
+              return true;
             }
           });
 
-    return variableNodeMatches;
+    return comparesToTerm;
   }
 
-  someTerm(callback) { return this.terms.some(callback); }
-
-  everyTerm(callback) { return this.terms.every(callback); }
-
   someOtherTerm(term, callback) {
     const termA = term, ///
           terms = this.terms.filter((term) => {
             const termB = term, ///
-                  termAEqualToTermB = termA.isEqualTo(termB);
+                  termAComparesToTermB = termA.compareTerm(termB);
 
-            if (!termAEqualToTermB) {
+            if (!termAComparesToTermB) {
               return true;
             }
           }),
@@ -218,9 +192,9 @@ export default define(class Equivalence extends Element {
     ];
 
     compress(combinedTerms, (combinedTermA, combinedTermB) => {
-      const combinedTermAEqualToCombinedTermB = combinedTermA.isEqualTo(combinedTermB);
+      const combinedTermAComparesToCombinedTermB = combinedTermA.compareTerm(combinedTermB);
 
-      if (!combinedTermAEqualToCombinedTermB) {
+      if (!combinedTermAComparesToCombinedTermB) {
         return true;
       }
     });
@@ -229,31 +203,70 @@ export default define(class Equivalence extends Element {
   }
 
   mergedWith(equivalence, context) {
-    const terms = equivalence.getTerms(),
+    let type;
+
+    type = equivalence.getType();
+
+    const types = [
+            this.type,
+            type
+          ],
+          terms = equivalence.getTerms(),
+          combinedType = combinedTypeFromTypes(types),
           combinedTerms = this.combineTerms(terms);
 
-    return instantiate((context) => {
+    type = combinedType;  ///
+
+    instantiate((context) => {
       const terms = combinedTerms,  ///
             equivalenceString = equivalenceStringFromTerms(terms),
             string = equivalenceString,  ///
-            equivalenceNode = instantiateEquivalence(string, context),
-            equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
+            equivalenceNode = instantiateEquivalence(string, context);
 
-      return equivalence;
+      equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
     }, context);
+
+    equivalence.setType(type);
+
+    return equivalence;
   }
 
   static name = "Equivalence";
 
   static fromEquality(equality, context) {
-    return instantiate((context) => {
+    let equivalence;
+
+    const type = equality.getType();
+
+    instantiate((context) => {
       const terms = equality.getTerms(),
             equivalenceString = equivalenceStringFromTerms(terms),
             string = equivalenceString,  ///
-            equivalenceNode = instantiateEquivalence(string, context),
-            equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
+            equivalenceNode = instantiateEquivalence(string, context);
 
-      return equivalence;
+      equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
     }, context);
+
+    equivalence.setType(type);
+
+    return equivalence;
   }
 });
+
+function combinedTypeFromTypes(types) {
+  const combinedType = types.reduce((combinedType, type) => {
+    if (combinedType === null) {
+      combinedType = type;  ///
+    } else {
+      const typeSubTypeOfCombinedType = type.isSubTypeOf(combinedType);
+
+      if (typeSubTypeOfCombinedType) {
+        combinedType = type;  ///
+      }
+    }
+
+    return combinedType;
+  }, null);
+
+  return combinedType;
+}

package/src/element/frame.js

@@ -3,11 +3,11 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
 import { instantiateFrame } from "../process/instantiate";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 import { metavariableFromFrameNode } from "../utilities/element";
-import { assumptionsStringFromAssumptions } from "../utilities/string";
+import { descend, reconcile, instantiate } from "../utilities/context";
+import { assumptionsStringFromAssumptions, metaLevelSubstitutionsStringFromMetaLevelSubstitutions } from "../utilities/string";
 
 export default define(class Frame extends Element {
   constructor(context, string, node, assumptions, metavariable) {
@@ -97,17 +97,17 @@ export default define(class Frame extends Element {
     return comparesToParamter;
   }
 
-  compareSubstitution(substitution, context) {
-    let comparesToSubstitution = false;
+  compareMetaLevelSubstitution(metaLevelSubstitution, context) {
+    let comparesToMetaLevelSubstitution = false;
 
     const frameString = this.getString(),  ///
-          substitutionString = substitution.getString();
+          metaLevelSubstitutioString = metaLevelSubstitution.getString();
 
-    context.trace(`Comparing the '${frameString}' frame to the '${substitutionString}' substitution...`);
+    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutioString}' meta-level substitutio...`);
 
-    if (!comparesToSubstitution) {
-      comparesToSubstitution = this.assumptions.some((assumption) => {
-        const assumptionComparesToSubstitution = assumption.compareSubstitution(substitution, context);
+    if (!comparesToMetaLevelSubstitution) {
+      comparesToMetaLevelSubstitution = this.assumptions.some((assumption) => {
+        const assumptionComparesToSubstitution = assumption.compareMetaLevelSubstitution(metaLevelSubstitution, context);
 
         if (assumptionComparesToSubstitution) {
           return true;
@@ -115,34 +115,34 @@ export default define(class Frame extends Element {
       });
     }
 
-    if (comparesToSubstitution) {
-      context.debug(`...compared the the '${frameString}' frame to the '${substitutionString}' substitutions.`);
+    if (comparesToMetaLevelSubstitution) {
+      context.debug(`...compared the the '${frameString}' frame to the '${metaLevelSubstitutioString}' meta-Level-substituution.`);
     }
 
-    return comparesToSubstitution;
+    return comparesToMetaLevelSubstitution;
   }
 
-  compareSubstitutions(substitutions, context) {
-    let comparesToSubstitutions;
+  compareMetaLevelSubstitutions(metaLevelSubstitutions, context) {
+    let comparesToMetaLevelSubstitutions;
 
     const frameString = this.getString(),  ///
-          substitutionsString = substitutions.asString();
+          metaLevelSubstitutionsString = metaLevelSubstitutionsStringFromMetaLevelSubstitutions(metaLevelSubstitutions);
 
-    context.trace(`Comparing the '${frameString}' frame to the '${substitutionsString}' substitutions...`);
+    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutionsString}' meta-level substitutio...`);
 
-    comparesToSubstitutions = substitutions.every((substitution) => {
-      const compaaresToSubstitution = this.compareSubstitution(substitution, context);
+    comparesToMetaLevelSubstitutions = metaLevelSubstitutions.every((metaLevelSubstitution) => {
+      const compaaresToMetaLevelSubstitution = this.compareMetaLevelSubstitution(metaLevelSubstitution, context);
 
-      if (compaaresToSubstitution) {
+      if (compaaresToMetaLevelSubstitution) {
         return true;
       }
     });
 
-    if (comparesToSubstitutions) {
-      context.debug(`...compared the '${frameString}' frame to the '${substitutionsString}' substitutions.`);
+    if (comparesToMetaLevelSubstitutions) {
+      context.debug(`...compared the '${frameString}' frame to the '${metaLevelSubstitutionsString}' metaLevelSubstitutions.`);
     }
 
-    return comparesToSubstitutions;
+    return comparesToMetaLevelSubstitutions;
   }
 
   compareMetavariableName(metavariableName) {
@@ -163,7 +163,7 @@ export default define(class Frame extends Element {
     return comparesToMetavariableName;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let frame = null;
 
     const frameString = this.getString();  ///
@@ -180,12 +180,14 @@ export default define(class Frame extends Element {
     } else {
       let validates = false;
 
-      const metavariableValidates = this.validatMetavariable(stated, context);
+      const metavariableValidates = this.validatMetavariable(context);
 
       if (metavariableValidates) {
-        const assumptionsValidate = this.validateAssumptions(stated, context);
+        const assumptionsValidate = this.validateAssumptions(context);
 
         if (assumptionsValidate) {
+          const stated = context.isStated();
+
           let validatesWhenStated = false,
               validatesWhenDerived = false;
 
@@ -251,17 +253,25 @@ export default define(class Frame extends Element {
     return validatesWhenDerived;
   }
 
-  validateAssumption(assumption, context) {
-    let assumptionValidates;
+  validateAssumption(assumption, assumptions, context) {
+    let assumptionValidates = false;
 
     const frameString = this.getString(), ///
           assumptionstring = assumption.getString();
 
     context.trace(`Validating the '${frameString}' frame's '${assumptionstring}' assumption.`);
 
-    const stated = true;  ///
+    reconcile((context) => {
+      descend((context) => {
+        assumption = assumption.validate(context);  ///
 
-    assumptionValidates = assumption.validate(stated, context);
+        if (assumption !== null) {
+          assumptions.push(assumption);
+
+          assumptionValidates = true;
+        }
+      }, context);
+    }, context);
 
     if (assumptionValidates) {
       context.debug(`...validated the '${frameString}' frame's '${assumptionstring}' assumption.`);
@@ -270,7 +280,7 @@ export default define(class Frame extends Element {
     return assumptionValidates;
   }
 
-  validateAssumptions(stated, context) {
+  validateAssumptions(context) {
     let assumptionsValidate;
 
     const singular = this.isSingular();
@@ -284,11 +294,9 @@ export default define(class Frame extends Element {
       const assumptions = [];
 
       assumptionsValidate = this.assumptions.every((assumption) => {
-        const assumptionValidates = this.validateAssumption(assumption, context);
+        const assumptionValidates = this.validateAssumption(assumption, assumptions, context);
 
         if (assumptionValidates) {
-          assumptions.push(assumption);
-
           return true;
         }
       });
@@ -305,7 +313,7 @@ export default define(class Frame extends Element {
     return assumptionsValidate;
   }
 
-  validatMetavariable(stated, context) {
+  validatMetavariable(context) {
     let metavariableValidates = false;
 
     const singular = this.isSingular();
@@ -316,7 +324,7 @@ export default define(class Frame extends Element {
 
       context.trace(`Validating the '${frameString}' frame's '${metavariableString}' metavariable...`);
 
-      const metavariable = this.metavariable.validate(context),  ///
+      const metavariable = this.metavariable.validate(context),
             metaTypeName = FRAME_META_TYPE_NAME,
             frameMetaType = context.findMetaTypeByMetaTypeName(metaTypeName),
             metavariableMetaTypeEqualToFrameMetaType = metavariable.isMetaTypeEqualTo(frameMetaType);

package/src/element/hypothesis.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import {instantiate} from "../utilities/context";
+import {descend, instantiate} from "../utilities/context";
 import { instantiateHypothesis } from "../process/instantiate";
 import { statementFromHypothesisNode } from "../utilities/element";
 
@@ -61,12 +61,13 @@ export default define(class Hypothesis extends Element {
     } else if (this.statement !== null) {
       let statementValidates = false;
 
-      const stated = true,
-            statement = this.statement.validate(stated, context);
+      descend((context) => {
+        const statement = this.statement.validate(context);
 
-      if (statement !== null) {
-        statementValidates = true;
-      }
+        if (statement !== null) {
+          statementValidates = true;
+        }
+      }, context);
 
       if (statementValidates) {
         const subproofOrProofAssertion = this;  ///

package/src/element/judgement.js

@@ -2,11 +2,9 @@
 
 import { Element } from "occam-languages";
 
-import elements from "../elements";
-
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
 import { instantiateJudgement } from "../process/instantiate";
+import { reconcile, instantiate } from "../utilities/context";
 import { judgementAssignmentFromJudgement } from "../process/assign";
 
 export default define(class Judgement extends Element {
@@ -41,8 +39,6 @@ export default define(class Judgement extends Element {
 
   getMetavariable() { return this.frame.getMetavariable(); }
 
-  compareMetavariableName(metavariableName) { return this.frame.compareMetavariableName(metavariableName); }
-
   matchJudgementNode(judgementNode) {
     const node = judgementNode, ///
           nodeMatches = this.matchNode(node),
@@ -51,6 +47,8 @@ export default define(class Judgement extends Element {
     return judgementNodeMatches;
   }
 
+  compareMetavariableName(metavariableName) { return this.frame.compareMetavariableName(metavariableName); }
+
   findValidJudgement(context) {
     const judgementNode = this.getJudgementNode(),
           judgement = context.findJudgementByJudgementNode(judgementNode),
@@ -59,7 +57,7 @@ export default define(class Judgement extends Element {
     return validJudgemenet;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let judgement = null;
 
     const judgementString = this.getString();  ///
@@ -75,31 +73,37 @@ export default define(class Judgement extends Element {
     } else {
       let validates = false;
 
-      const frameValidates = this.validateFrame(stated, context);
+      reconcile((context) => {
+        const frameValidates = this.validateFrame(context);
 
-      if (frameValidates) {
-        const assumptionValidates = this.validateAssumption(stated, context);
+        if (frameValidates) {
+          const assumptionValidates = this.validateAssumption(context);
 
-        if (assumptionValidates) {
-          let validatesWhenStated = false,
-              validatesWhenDerived = false;
+          if (assumptionValidates) {
+            const stated = context.isStated();
 
-          if (stated) {
-            validatesWhenStated = this.validateWhenStated(context);
-          } else {
-            validatesWhenDerived = this.validateWhenDerived(context);
-          }
+            let validatesWhenStated = false,
+                validatesWhenDerived = false;
+
+            if (stated) {
+              validatesWhenStated = this.validateWhenStated(context);
+            } else {
+              validatesWhenDerived = this.validateWhenDerived(context);
+            }
 
-          if (validatesWhenStated || validatesWhenDerived) {
-            validates = true;
+            if (validatesWhenStated || validatesWhenDerived) {
+              validates = true;
+            }
           }
         }
-      }
+      }, context);
 
       if (validates) {
         judgement = this; ///
 
-        context.addJudgement(judgement)
+        this.assign(context);
+
+        context.addJudgement(judgement);
 
         context.debug(`...validated the '${judgementString}' judgement.`);
       }
@@ -108,7 +112,7 @@ export default define(class Judgement extends Element {
     return judgement;
   }
 
-  validateFrame(stated, context) {
+  validateFrame(context) {
     let frameValidates = false;
 
     const frameString = this.frame.getString(),
@@ -116,7 +120,7 @@ export default define(class Judgement extends Element {
 
     context.trace(`Validating the '${judgementString}' judgement's '${frameString}' frame...`);
 
-    const frame = this.frame.validate(stated, context);
+    const frame = this.frame.validate(context);
 
     if (frame !== null) {
       this.frame = frame;
@@ -131,7 +135,7 @@ export default define(class Judgement extends Element {
     return frameValidates;
   }
 
-  validateAssumption(stated, context) {
+  validateAssumption(context) {
     let assumptionValidates = false;
 
     const assumptionString = this.assumption.getString(),
@@ -139,7 +143,7 @@ export default define(class Judgement extends Element {
 
     context.trace(`Validating the '${judgementString}' judgement's '${assumptionString}' assumption...`);
 
-    const assumption = this.assumption.validate(stated, context);
+    const assumption = this.assumption.validate(context);
 
     if (assumption !== null) {
       this.assumption = assumption;
@@ -177,11 +181,9 @@ export default define(class Judgement extends Element {
 
     context.trace(`Validating the '${judgementString}' derived judgement...`);
 
-    const metavariable = this.assumption.getMetavariable(),
-          reference = referenceFromMetavariable(metavariable, context),
-          topLevelMetaAssertion = context.findTopLevelMetaAssertionByReference(reference),
-          substitutions = topLevelMetaAssertion.getSubstitutions(),
-          frameComparesToSubstitutions = this.frame.compareSubstitutions(substitutions, context);
+    const topLevelMetaAssertion = this.assumption.getTopLevelMetaAssertion(),
+          metaLevelSubstitutions = topLevelMetaAssertion.getMetaLevelSubstitutions(),
+          frameComparesToSubstitutions = this.frame.compareMetaLevelSubstitutions(metaLevelSubstitutions, context);
 
     if (frameComparesToSubstitutions) {
       validatesWhenDerived = true;
@@ -194,16 +196,17 @@ export default define(class Judgement extends Element {
     return validatesWhenDerived;
   }
 
-  assign(stated, context) {
+  assign(context) {
+    const stated = context.isStated();
+
     if (!stated) {
       return;
     }
 
     const judgement = this, ///
-          judgementAssignment = judgementAssignmentFromJudgement(judgement, context),
-          assignment = judgementAssignment; ///
+          judgementAssignment = judgementAssignmentFromJudgement(judgement, context);
 
-    context.addAssignment(assignment);
+    context.addAssignment(judgementAssignment);
   }
 
   toJSON() {
@@ -247,12 +250,3 @@ function assumptionFromJudgementNode(judgementNode, context) {
 
   return assumption;
 }
-
-function referenceFromMetavariable(metavariable, context) {
-  const { Reference } = elements,
-        metavariableNode = metavariable.getNode(),
-        reference = Reference.fromMetavariableNode(metavariableNode, context);
-
-  return reference;
-}
-