occam-verify-cli 1.0.768 → 1.0.781

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

@@ -4,25 +4,38 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
+import { instantiate } from "../utilities/context";
 import { instantiateEquivalence } from "../process/instantiate";
 import { stripBracketsFromTermNode } from "../utilities/brackets";
 import { equivalenceStringFromTerms } from "../utilities/string";
 import { equivalenceFromEquivalenceNode } from "../utilities/element";
-import { instantiate, sanitisedContextFromContext } from "../utilities/context";
 
 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); }
 
-            if (singularVariableNode !== null) {
-              const variableNodeB = singularVariableNode, ///
-                    variableNodeAMatchesVariableNodeB = variableNodeA.match(variableNodeB);
+  everyTerm(callback) { return this.terms.every(callback); }
+
+  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,35 +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) {
-    const santisedContext = sanitisedContextFromContext(context);
+    let equivalence;
 
-    context = santisedContext;  ///
+    const type = equality.getType();
 
-    return instantiate((context) => {
+    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/equivalences.js

@@ -203,8 +203,11 @@ export default define(class Equivalences extends Element {
   static fromNothing(context) {
     const string = EMPTY_STRING,
           node = null,
-          array = [],
-          equivalences = new Equivalences(context, string, node, array);
+          array = [];
+
+    context = null;
+
+    const equivalences = new Equivalences(context, string, node, array);
 
     return equivalences;
   }

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) {
@@ -46,22 +46,6 @@ export default define(class Frame extends Element {
     return metavariableName;
   }
 
-  matchFrameNode(frameNode) {
-    const node = frameNode, ///
-          nodeMatches = this.matchNode(node),
-          frameNodeMatches = nodeMatches; ///
-
-    return frameNodeMatches;
-  }
-
-  findValidFrame(context) {
-    const frameNode = this.getFrameNode(),
-          frame = context.findFrameByFrameNode(frameNode),
-          validFrame = frame; ///
-
-    return validFrame;
-  }
-
   isEqualTo(frame) {
     const frameNode = frame.getNode(),
           frameNodeMatches = this.matchFrameNode(frameNode),
@@ -77,6 +61,26 @@ export default define(class Frame extends Element {
     return singular;
   }
 
+  matchFrameNode(frameNode) {
+    const node = frameNode, ///
+          nodeMatches = this.matchNode(node),
+          frameNodeMatches = nodeMatches; ///
+
+    return frameNodeMatches;
+  }
+
+  matchMetavariableNode(metavariableNode) {
+    let metavariableNodeMatches = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      metavariableNodeMatches = this.metavariable.matchMetavariableNode(metavariableNode);
+    }
+
+    return metavariableNodeMatches;
+  }
+
   compareParameter(parameter) {
     let comparesToParamter = false;
 
@@ -97,73 +101,83 @@ export default define(class Frame extends Element {
     return comparesToParamter;
   }
 
-  compareSubstitution(substitution, context) {
-    let comparesToSubstitution = false;
+  compareMetavariableName(metavariableName) {
+    let comparesToMetavariableName = false;
 
-    const frameString = this.getString(),  ///
-          substitutionString = substitution.getString();
+    const singular = this.isSingular();
 
-    context.trace(`Comparing the '${frameString}' frame to the '${substitutionString}' substitution...`);
+    if (singular) {
+      const metavariableNameA = metavariableName ///
 
-    if (!comparesToSubstitution) {
-      comparesToSubstitution = this.assumptions.some((assumption) => {
-        const assumptionComparesToSubstitution = assumption.compareSubstitution(substitution, context);
+      metavariableName = this.getMetavariableName();
 
-        if (assumptionComparesToSubstitution) {
-          return true;
-        }
-      });
-    }
+      const metavariableNameB = metavariableName; ///
 
-    if (comparesToSubstitution) {
-      context.debug(`...compared the the '${frameString}' frame to the '${substitutionString}' substitutions.`);
+      comparesToMetavariableName = (metavariableNameA === metavariableNameB);
     }
 
-    return comparesToSubstitution;
+    return comparesToMetavariableName;
   }
 
-  compareSubstitutions(substitutions, context) {
-    let comparesToSubstitutions;
+  compareMetaLevelSubstitution(metaLevelSubstitution, context) {
+    let comparesToMetaLevelSubstitution;
 
     const frameString = this.getString(),  ///
-          substitutionsString = substitutions.asString();
+          metaLevelSubstitutionString = metaLevelSubstitution.getString();
+
+    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutionString}' meta-level substitution...`);
 
-    context.trace(`Comparing the '${frameString}' frame to the '${substitutionsString}' substitutions...`);
+    const metavariableNode = this.metavariable.getNode(),
+          judgements = context.findJudgementsByMetavariableNode(metavariableNode),
+          assumptions = assumptionsFromJudgements(judgements);
 
-    comparesToSubstitutions = substitutions.every((substitution) => {
-      const compaaresToSubstitution = this.compareSubstitution(substitution, context);
+    comparesToMetaLevelSubstitution = assumptions.some((assumption) => {
+      const assumptionComparesToSubstitution = assumption.compareMetaLevelSubstitution(metaLevelSubstitution, context);
 
-      if (compaaresToSubstitution) {
+      if (assumptionComparesToSubstitution) {
         return true;
       }
     });
 
-    if (comparesToSubstitutions) {
-      context.debug(`...compared the '${frameString}' frame to the '${substitutionsString}' substitutions.`);
+    if (comparesToMetaLevelSubstitution) {
+      context.debug(`...compared the '${frameString}' frame to the '${metaLevelSubstitutionString}' meta-level substitution.`);
     }
 
-    return comparesToSubstitutions;
+    return comparesToMetaLevelSubstitution;
   }
 
-  compareMetavariableName(metavariableName) {
-    let comparesToMetavariableName = false;
+  compareMetaLevelSubstitutions(metaLevelSubstitutions, context) {
+    let comparesToMetaLevelSubstitutions;
 
-    const singular = this.isSingular();
+    const frameString = this.getString(),  ///
+          metaLevelSubstitutionsString = metaLevelSubstitutionsStringFromMetaLevelSubstitutions(metaLevelSubstitutions);
 
-    if (singular) {
-      const metavariableNameA = metavariableName ///
+    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutionsString}' meta-level substitution...`);
 
-      metavariableName = this.getMetavariableName();
+    comparesToMetaLevelSubstitutions = metaLevelSubstitutions.every((metaLevelSubstitution) => {
+      const compaaresToMetaLevelSubstitution = this.compareMetaLevelSubstitution(metaLevelSubstitution, context);
 
-      const metavariableNameB = metavariableName; ///
+      if (compaaresToMetaLevelSubstitution) {
+        return true;
+      }
+    });
 
-      comparesToMetavariableName = (metavariableNameA === metavariableNameB);
+    if (comparesToMetaLevelSubstitutions) {
+      context.debug(`...compared the '${frameString}' frame to the '${metaLevelSubstitutionsString}' metaLevelSubstitutions.`);
     }
 
-    return comparesToMetavariableName;
+    return comparesToMetaLevelSubstitutions;
   }
 
-  validate(stated, context) {
+  findValidFrame(context) {
+    const frameNode = this.getFrameNode(),
+          frame = context.findFrameByFrameNode(frameNode),
+          validFrame = frame; ///
+
+    return validFrame;
+  }
+
+  validate(context) {
     let frame = null;
 
     const frameString = this.getString();  ///
@@ -180,12 +194,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 +267,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 +294,7 @@ export default define(class Frame extends Element {
     return assumptionValidates;
   }
 
-  validateAssumptions(stated, context) {
+  validateAssumptions(context) {
     let assumptionsValidate;
 
     const singular = this.isSingular();
@@ -284,11 +308,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 +327,7 @@ export default define(class Frame extends Element {
     return assumptionsValidate;
   }
 
-  validatMetavariable(stated, context) {
+  validatMetavariable(context) {
     let metavariableValidates = false;
 
     const singular = this.isSingular();
@@ -370,3 +392,12 @@ function assumptionsFromFrameNode(frameNode, context) {
   return assumptions;
 }
 
+function assumptionsFromJudgements(judgements) {
+  const assumptions = judgements.map((judgement) => {
+    const assumption = judgement.getAssumption();
+
+    return assumption;
+  });
+
+  return assumptions;
+}

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