occam-verify-cli 1.0.781 → 1.0.785

package/src/element/assumption.js

@@ -3,8 +3,11 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { descend, instantiate } from "../utilities/context";
+import { unifyAssumption } from "../process/unify";
 import { instantiateAssumption } from "../process/instantiate";
+import { assumptionFromAssumptionNode } from "../utilities/element";
+import { assumptionStringFromStatementAndReference } from "../utilities/string";
+import { join, descend, simplify, reconcile, instantiate } from "../utilities/context";
 
 export default define(class Assumption extends Element {
   constructor(context, string, node, reference, statement) {
@@ -33,6 +36,14 @@ export default define(class Assumption extends Element {
 
   getTopLevelMetaAssertion() { return this.reference.getTopLevelMetaAssertion(); }
 
+  isEqualTo(assumption) {
+    const assumptionNode = assumption.getNode(),
+          assumptionNodeMatches = this.matchAssumptionNode(assumptionNode),
+          equalTo = assumptionNodeMatches;  ///
+
+    return equalTo;
+  }
+
   matchAssumptionNode(assumptionNode) {
     const node = assumptionNode, ///
           nodeMatches = this.matchNode(node),
@@ -41,39 +52,26 @@ export default define(class Assumption extends Element {
     return assumptionNodeMatches;
   }
 
-  compareMetaLevelSubstitution(metaLevelSubstitution, context) {
-    let comparesToMetaLevelSubstitution = false;
-
-    const assumptionString = this.getString(),  ///
-          metaLevelSubstitutionString = metaLevelSubstitution.getString();
-
-    context.trace(`Comparing the '${assumptionString}' assumption to the '${metaLevelSubstitutionString}' meta-level substitution...`);
-
-    debugger
-
-    if (comparesToMetaLevelSubstitution) {
-      context.debug(`...compared the '${assumptionString}' assumption to the '${metaLevelSubstitutionString}' meta-level substitution.`);
-    }
-
-    return comparesToMetaLevelSubstitution;
-  }
-
-  findValidAssumption(context) {
+  findValidAssumption(context, metaLevel = false) {
     const assumptionNode = this.getAssumptionNode(),
-          assumption = context.findAssumptionByAssumptionNode(assumptionNode),
+          assumption = context.findAssumptionByAssumptionNode(assumptionNode, metaLevel),
           validAssumption = assumption;  ///
 
     return validAssumption;
   }
 
-  validate(context) {
+  validate(context, metaLevel = false) {
     let assumption = null;
 
+    if (metaLevel) {
+      context = this.getContext();
+    }
+
     const assumptionString = this.getString();  ///
 
     context.trace(`Validating the '${assumptionString}' assumption...`);
 
-    const validAssumption = this.findValidAssumption(context);
+    const validAssumption = this.findValidAssumption(context, metaLevel);
 
     if (validAssumption) {
       assumption = validAssumption; ///
@@ -108,7 +106,7 @@ export default define(class Assumption extends Element {
       if (validates) {
         assumption = this;  ///
 
-        context.addAssumption(assumption);
+        context.addAssumption(assumption, metaLevel);
 
         context.debug(`...validated the '${assumptionString}' assumption.`);
       }
@@ -216,6 +214,39 @@ export default define(class Assumption extends Element {
     return validatesWhenDerived;
   }
 
+  unifyAssumption(assumption, generalContext, specificContext) {
+    let assumptionUnifies;
+
+    const context = specificContext,  ///
+          generalAssumption = this, ///
+          specificAssumption = assumption,  ///
+          generalAssumptionString = generalAssumption.getString(),
+          specificAssumptionString = specificAssumption.getString();
+
+    context.trace(`Unifying the '${specificAssumptionString}' assumption with the '${generalAssumptionString}' assumption...`);
+
+    const assumptionContext = assumption.getContext();
+
+    specificContext = assumptionContext;  ///
+
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        assumptionUnifies = unifyAssumption(generalAssumption, specificAssumption, generalContext, specificContext);
+
+        if (assumptionUnifies) {
+          specificContext.commit(context);
+        }
+
+      }, specificContext);
+    }, specificContext, context);
+
+    if (assumptionUnifies) {
+      context.debug(`...unified the '${specificAssumptionString}' assumption with the '${generalAssumptionString}' assumption.`);
+    }
+
+    return assumptionUnifies;
+  }
+
   unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
     let topLevelMetaAssertionUnifies;
 
@@ -265,6 +296,24 @@ export default define(class Assumption extends Element {
 
     return assumption;
   }
+
+  static fromStatementAndReference(statement, reference, context) {
+    let assumption;
+
+    simplify((context) => {
+      instantiate((context) => {
+        const assumptionString = assumptionStringFromStatementAndReference(statement, reference),
+              string = assumptionString,  ///
+              assumptionNode = instantiateAssumption(string, context);
+
+        assumption = assumptionFromAssumptionNode(assumptionNode, context);
+
+        assumption.setContext(context);
+      }, context);
+    }, context);
+
+    return assumption;
+  }
 });
 
 function referenceFromAssumptionNode(assumptionNode, context) {

package/src/element/frame.js

@@ -7,7 +7,7 @@ import { instantiateFrame } from "../process/instantiate";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 import { metavariableFromFrameNode } from "../utilities/element";
 import { descend, reconcile, instantiate } from "../utilities/context";
-import { assumptionsStringFromAssumptions, metaLevelSubstitutionsStringFromMetaLevelSubstitutions } from "../utilities/string";
+import { assumptionsStringFromAssumptions } from "../utilities/string";
 
 export default define(class Frame extends Element {
   constructor(context, string, node, assumptions, metavariable) {
@@ -119,56 +119,6 @@ export default define(class Frame extends Element {
     return comparesToMetavariableName;
   }
 
-  compareMetaLevelSubstitution(metaLevelSubstitution, context) {
-    let comparesToMetaLevelSubstitution;
-
-    const frameString = this.getString(),  ///
-          metaLevelSubstitutionString = metaLevelSubstitution.getString();
-
-    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutionString}' meta-level substitution...`);
-
-    const metavariableNode = this.metavariable.getNode(),
-          judgements = context.findJudgementsByMetavariableNode(metavariableNode),
-          assumptions = assumptionsFromJudgements(judgements);
-
-    comparesToMetaLevelSubstitution = assumptions.some((assumption) => {
-      const assumptionComparesToSubstitution = assumption.compareMetaLevelSubstitution(metaLevelSubstitution, context);
-
-      if (assumptionComparesToSubstitution) {
-        return true;
-      }
-    });
-
-    if (comparesToMetaLevelSubstitution) {
-      context.debug(`...compared the '${frameString}' frame to the '${metaLevelSubstitutionString}' meta-level substitution.`);
-    }
-
-    return comparesToMetaLevelSubstitution;
-  }
-
-  compareMetaLevelSubstitutions(metaLevelSubstitutions, context) {
-    let comparesToMetaLevelSubstitutions;
-
-    const frameString = this.getString(),  ///
-          metaLevelSubstitutionsString = metaLevelSubstitutionsStringFromMetaLevelSubstitutions(metaLevelSubstitutions);
-
-    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutionsString}' meta-level substitution...`);
-
-    comparesToMetaLevelSubstitutions = metaLevelSubstitutions.every((metaLevelSubstitution) => {
-      const compaaresToMetaLevelSubstitution = this.compareMetaLevelSubstitution(metaLevelSubstitution, context);
-
-      if (compaaresToMetaLevelSubstitution) {
-        return true;
-      }
-    });
-
-    if (comparesToMetaLevelSubstitutions) {
-      context.debug(`...compared the '${frameString}' frame to the '${metaLevelSubstitutionsString}' metaLevelSubstitutions.`);
-    }
-
-    return comparesToMetaLevelSubstitutions;
-  }
-
   findValidFrame(context) {
     const frameNode = this.getFrameNode(),
           frame = context.findFrameByFrameNode(frameNode),
@@ -391,13 +341,3 @@ 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/judgement.js

@@ -40,6 +40,8 @@ export default define(class Judgement extends Element {
 
   getMetavariable() { return this.frame.getMetavariable(); }
 
+  getMetavariableNode() { return this.frame.getMetavariableNode(); }
+
   matchJudgementNode(judgementNode) {
     const node = judgementNode, ///
           nodeMatches = this.matchNode(node),
@@ -185,12 +187,40 @@ export default define(class Judgement extends Element {
     context.trace(`Validating the '${judgementString}' derived judgement...`);
 
     const topLevelMetaAssertion = this.assumption.getTopLevelMetaAssertion(),
-          metaLevelSubstitutions = topLevelMetaAssertion.getMetaLevelSubstitutions(),
-          frameComparesToSubstitutions = this.frame.compareMetaLevelSubstitutions(metaLevelSubstitutions, context);
+          metavariableNode = this.getMetavariableNode(),
+          judgements = context.findJudgementsByMetavariableNode(metavariableNode);
 
-    if (frameComparesToSubstitutions) {
-      validatesWhenDerived = true;
-    }
+    let assumptions;
+
+    assumptions = topLevelMetaAssertion.getAssumptions();
+
+    const specificAssumptions = assumptions; ///
+
+    assumptions = assumptionsFromJudgements(judgements);
+
+    const generalAssumptions = assumptions;  ///
+
+    reconcile((context) => {
+      const specificAssumptionsUnify = specificAssumptions.every((specificAssumption) => {
+        const specificAssumptionUnifies = generalAssumptions.some((generalAssumption) => {
+          const generalContext = context, ///
+                specificContext = context,  ///
+                specificAssumptionUnifies = generalAssumption.unifyAssumption(specificAssumption, generalContext, specificContext);
+
+          if (specificAssumptionUnifies) {
+            return true;
+          }
+        });
+
+        if (specificAssumptionUnifies) {
+          return true;
+        }
+      });
+
+      if (specificAssumptionsUnify) {
+        validatesWhenDerived = true;
+      }
+    }, context);
 
     if (validatesWhenDerived) {
       context.debug(`...validated the '${judgementString}' derived judgement.`);
@@ -254,6 +284,16 @@ function frameFromJudgementNode(judgementNode, context) {
   return frame;
 }
 
+function assumptionsFromJudgements(judgements) {
+  const assumptions = judgements.map((judgement) => {
+    const assumption = judgement.getAssumption();
+
+    return assumption;
+  });
+
+  return assumptions;
+}
+
 function assumptionFromJudgementNode(judgementNode, context) {
   const assumptionNode = judgementNode.getAssumptionNode(),
         assumption = context.findAssumptionByAssumptionNode(assumptionNode);

package/src/element/metavariable.js

@@ -290,11 +290,10 @@ export default define(class Metavariable extends Element {
       frameUnifies = true;
     } else {
       const metavariableName = this.getMetavariableName(),
-            simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
+            substitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
 
-      if (simpleSubstitution !== null) {
-        const substitution = simpleSubstitution,  ///
-              substitutionFrameComparesToFrame = substitution.compareFrame(frame, context);
+      if (substitution !== null) {
+        const substitutionFrameComparesToFrame = substitution.compareFrame(frame, context);
 
         if (substitutionFrameComparesToFrame) {
           const frameSubstitution = substitution, ///
@@ -402,12 +401,10 @@ export default define(class Metavariable extends Element {
       referenceUnifies = true;
     } else {
       const metavariableName = this.getMetavariableName(),
-            simpleSubstitutionPresent = context.isSimpleSubstitutionPresentByMetavariableName(metavariableName);
+            substitution = context.findSubstitutionByMetavariableName(metavariableName);
 
-      if (simpleSubstitutionPresent) {
-        const simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName),
-              substitution = simpleSubstitution,  ///
-              substitutionReferenceComparesToReference = substitution.compareReference(reference, context);
+      if (substitution !== null) {
+        const substitutionReferenceComparesToReference = substitution.compareReference(reference, context);
 
         if (substitutionReferenceComparesToReference) {
           const referenceSubstitution = substitution, ///

package/src/element/topLevelMetaAssertion.js

@@ -7,23 +7,23 @@ import { topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "..
 import { labelFromJSON,
          labelToLabelJSON,
          deductionFromJSON,
+         assumptionsFromJSON,
          suppositionsFromJSON,
          deductionToDeductionJSON,
-         suppositionsToSuppositionsJSON,
-         metaLevelSubstitutionsFromJSON,
-         metaLevelSubstitutionsToMetaLevelSubstitutionsJSON } from "../utilities/json";
+         assumptionsToAssumptionsJSON,
+         suppositionsToSuppositionsJSON } from "../utilities/json";
 
 const { asyncForwardsEvery } = asynchronousUtilities;
 
 export default class TopLevelMetaAssertion extends Element {
-  constructor(context, string, node, label, suppositions, deduction, proof, metaLevelSubstitutions) {
+  constructor(context, string, node, label, suppositions, deduction, proof, assumptions) {
     super(context, string, node);
 
     this.label = label;
     this.suppositions = suppositions;
     this.deduction = deduction;
     this.proof = proof;
-    this.metaLevelSubstitutions = metaLevelSubstitutions;
+    this.assumptions = assumptions;
   }
 
   getLabel() {
@@ -42,8 +42,8 @@ export default class TopLevelMetaAssertion extends Element {
     return this.proof;
   }
 
-  getMetaLevelSubstitutions() {
-    return this.metaLevelSubstitutions;
+  getAssumptions() {
+    return this.assumptions;
   }
 
   getStatement() {
@@ -121,7 +121,7 @@ export default class TopLevelMetaAssertion extends Element {
           }
         }
       }
-    }, this.metaLevelSubstitutions, context);
+    }, this.assumptions, context);
 
     if (verifies) {
       context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion.`);
@@ -234,16 +234,16 @@ export default class TopLevelMetaAssertion extends Element {
     const labelJSON = labelToLabelJSON(this.label),
           deductionJSON = deductionToDeductionJSON(this.deduction),
           suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),
-          metaLevelSubstitutionsJSON = metaLevelSubstitutionsToMetaLevelSubstitutionsJSON(this.metaLevelSubstitutions),
+          assumptionsJSON = assumptionsToAssumptionsJSON(this.assumptions),
           label = labelJSON,  ///
           deduction = deductionJSON,  ///
           suppositions = suppositionsJSON,  ///
-          metaLevelSubstitutions = metaLevelSubstitutionsJSON,  ///
+          assumptions = assumptionsJSON,  ///
           json = {
             label,
             deduction,
             suppositions,
-            metaLevelSubstitutions
+            assumptions
           };
 
     return json;
@@ -253,11 +253,11 @@ export default class TopLevelMetaAssertion extends Element {
     const label = labelFromJSON(json, context),
           deduction = deductionFromJSON(json, context),
           suppositions = suppositionsFromJSON(json, context),
-          metaLevelSubstitutions = metaLevelSubstitutionsFromJSON(json, context),
+          assumptions = assumptionsFromJSON(json, context),
           node = null,
           proof = null,
           string = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
-          topLevelMetaAssertion = new Class(context, string, node, label, suppositions, deduction, proof, metaLevelSubstitutions);
+          topLevelMetaAssertion = new Class(context, string, node, label, suppositions, deduction, proof, assumptions);
 
     return topLevelMetaAssertion;
   }

package/src/nonTerminalNodeMap.js

@@ -79,7 +79,6 @@ import SimpleTypeDeclarationNode from "./node/declaration/simpleType";
 import CombinatorDeclarationNode from "./node/declaration/combinator";
 import ReferenceSubstitutionNode from "./node/substitution/reference";
 import StatementSubstitutionNode from "./node/substitution/statement";
-import MetaLevelSubstitutionNode from "./node/substitution/metaLevel";
 import TypePrefixDeclarationNode from "./node/declaration/typePrefix";
 import ComplexTypeDeclarationNode from "./node/declaration/complexType";
 import DonstructorDeclarationNode from "./node/declaration/constructor";
@@ -164,7 +163,6 @@ import {
   COMBINATOR_DECLARATION_RULE_NAME,
   REFERENCE_SUBSTITUTION_RULE_NAME,
   STATEMENT_SUBSTITUTION_RULE_NAME,
-  META_LEVEL_SUBSTITUTION_RULE_NAME,
   SIMPLE_TYPE_DECLARATION_RULE_NAME,
   CONSTRUCTOR_DECLARATION_RULE_NAME,
   TYPE_PREFIX_DECLARATION_RULE_NAME,
@@ -250,7 +248,6 @@ const NonTerminalNodeMap = {
   [COMBINATOR_DECLARATION_RULE_NAME]: CombinatorDeclarationNode,
   [STATEMENT_SUBSTITUTION_RULE_NAME]: StatementSubstitutionNode,
   [REFERENCE_SUBSTITUTION_RULE_NAME]: ReferenceSubstitutionNode,
-  [META_LEVEL_SUBSTITUTION_RULE_NAME]: MetaLevelSubstitutionNode,
   [SIMPLE_TYPE_DECLARATION_RULE_NAME]: SimpleTypeDeclarationNode,
   [TYPE_PREFIX_DECLARATION_RULE_NAME]: TypePrefixDeclarationNode,
   [CONSTRUCTOR_DECLARATION_RULE_NAME]: DonstructorDeclarationNode,

package/src/preamble.js

@@ -57,7 +57,6 @@ import SimpleTypeDeclaration from "./element/declaration/simpleType";
 import StatementSubstitution from "./element/substitution/statement";
 import ReferenceSubstitution from "./element/substitution/reference";
 import CombinatorDeclaration from "./element/declaration/combinator";
-import MetaLevelSubstitution from "./element/substitution/metaLevel";
 import TypePrefixDeclaration from "./element/declaration/typePrefix";
 import ConstructorDeclaration from "./element/declaration/constructor";
 import ComplexTypeDeclaration from "./element/declaration/complexType";

package/src/process/instantiate.js

@@ -34,8 +34,7 @@ import { TERM_RULE_NAME,
          CONTAINED_ASSERTION_RULE_NAME,
          SATISFIES_ASSERTION_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME,
-         REFERENCE_SUBSTITUTION_RULE_NAME,
-         META_LEVEL_SUBSTITUTION_RULE_NAME } from "../ruleNames";
+         REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
 const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       typePlaceholderRule = ruleFromRuleName(TYPE_RULE_NAME),
@@ -70,8 +69,7 @@ const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       containedAssertionPlaceholderRule = ruleFromRuleName(CONTAINED_ASSERTION_RULE_NAME),
       satisfiesAssertionPlaceholderRule = ruleFromRuleName(SATISFIES_ASSERTION_RULE_NAME),
       statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
-      referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME),
-      metaLevelSubstitutionPlaceholderRule = ruleFromRuleName(META_LEVEL_SUBSTITUTION_RULE_NAME);
+      referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
 
 export function instantiatePremise(string, context) {
   string = `${string}
@@ -161,8 +159,6 @@ export function instantiateStatementSubstitution(string, context) { return insta
 
 export function instantiateReferenceSubstitution(string, context) { return instantiate(referenceSubstitutionPlaceholderRule, string, context); }
 
-export function instantiateMetaLevelSubstitution(string, context) { return instantiate(metaLevelSubstitutionPlaceholderRule, string, context); }
-
 function instantiate(placeholderRule, string, context) {
   let node;
 

package/src/process/unify.js

@@ -14,8 +14,9 @@ const typeNodeQuery = nodeQuery("/type"),
       frameNodeQuery = nodeQuery("/frame"),
       metaTypeNodeQuery = nodeQuery("/metaType"),
       statementNodeQuery = nodeQuery("/statement"),
+      metavariableNodeQuery = nodeQuery("/metavariable"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
-      frameAMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
+      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       assumptionMetavariableNodeQuery = nodeQuery("/assumption/metavariable!");
 
@@ -89,7 +90,7 @@ class MetaLevelPass extends ZipPassBase {
       }
     },
     {
-      generalNodeQuery: frameAMetavariableNodeQuery,
+      generalNodeQuery: frameMetavariableNodeQuery,
       specificNodeQuery: frameNodeQuery,
       run: (generalFrameMetavariableNode, specificFrameNode, generalContext, specificContext) => {
         let success = false;
@@ -147,6 +148,98 @@ class MetaLevelPass extends ZipPassBase {
   ];
 }
 
+class AssumptionPass extends ZipPass {
+  static maps = [
+    {
+      generalNodeQuery: statementMetavariableNodeQuery,
+      specificNodeQuery: statementNodeQuery,
+      run: (generalStatementMetavariableNode, specificStatementNode, generalContext, specificContext) => {
+        let success = false;
+
+        const statementNode = specificStatementNode, ///
+              metavariableNode = generalStatementMetavariableNode,  ///
+              metavariableName = metavariableNode.getMetavariableName();
+
+        let context;
+
+        context = generalContext; ///
+
+        const metavariable = context.findMetavariableByMetavariableName(metavariableName);
+
+        context = specificContext;  ///
+
+        const statement = context.findStatementByStatementNode(statementNode),
+              substitution = null,
+              statementUnifies = metavariable.unifyStatement(statement, substitution, generalContext, specificContext);
+
+        if (statementUnifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      generalNodeQuery: metavariableNodeQuery,
+      specificNodeQuery: metavariableNodeQuery,
+      run: (generalMetavariableNode, specificMetavariableNode, generalContext, specificContext) => {
+        let success = false;
+
+        let context,
+            metavariableNode;
+
+        context = generalContext; ///
+
+        metavariableNode = generalMetavariableNode;  ///
+
+        const metavariableName = metavariableNode.getMetavariableName(),
+              metavariable = context.findMetavariableByMetavariableName(metavariableName);
+
+        context = specificContext;  ///
+
+        metavariableNode = specificMetavariableNode; ///
+
+        const reference = context.findReferenceByMetavariableNode(metavariableNode),
+              referenceUnifies = metavariable.unifyReference(reference, generalContext, specificContext);
+
+        if (referenceUnifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      generalNodeQuery: termVariableNodeQuery,
+      specificNodeQuery: termNodeQuery,
+      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
+        let success = false;
+
+        const termNode = specificTermNode, ///
+              variableNode = generalTermVariableNode, ///
+              variableIdentifier = variableNode.getVariableIdentifier();
+
+        let context;
+
+        context = generalContext; ///
+
+        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
+
+        context = specificContext;  ///
+
+        const term = context.findTermByTermNode(termNode),
+              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+
+        if (termUnifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
 class CombinatorPass extends ZipPass {
   static maps = [
     {
@@ -307,7 +400,7 @@ class MetavariablePass extends ZipPass {
 class SubstitutionPass extends ZipPass {
   static maps = [
     {
-      generalNodeQuery: frameAMetavariableNodeQuery,
+      generalNodeQuery: frameMetavariableNodeQuery,
       specificNodeQuery: frameNodeQuery,
       run: (generalFrameMetavariableNode, specificFrameNode, generalContext, specificContext) => {
         let success = false;
@@ -399,6 +492,7 @@ class IntrinsicLevelPass extends ZipPass {
 }
 
 const metaLevelPass = new MetaLevelPass(),
+      assumptionPass = new AssumptionPass(),
       combinatorPass = new CombinatorPass(),
       constructorPass = new ConstructorPass(),
       metavariablePass = new MetavariablePass(),
@@ -421,14 +515,30 @@ export function unifyStatement(generalStatement, specificStatement, generalConte
   return statementUnifies;
 }
 
+export function unifyAssumption(generalAssumption, specificAssumption, generalContext, specificContext) {
+  let assumptionUnifies = false;
+
+  const generalAssumptionNode = generalAssumption.getNode(),
+        specificAssumptionNode = specificAssumption.getNode(),
+        generalNode = generalAssumptionNode, ///
+        specificNode = specificAssumptionNode,  ///
+        success = assumptionPass.run(generalNode, specificNode, generalContext, specificContext);
+
+  if (success) {
+    assumptionUnifies = true;
+  }
+
+  return assumptionUnifies;
+}
+
 export function unifySubstitution(generalSubstitution, specificSubstitution, generalContext, specificContext) {
   let substitutionUnifies = false;
 
   const generalSubstitutionNode = generalSubstitution.getNode(),
-        specificSubstitutionNode = specificSubstitution.getNode(),
-        generalNode = generalSubstitutionNode, ///
-        specificNode = specificSubstitutionNode,  ///
-        success = substitutionPass.run(generalNode, specificNode, generalContext, specificContext);
+    specificSubstitutionNode = specificSubstitution.getNode(),
+    generalNode = generalSubstitutionNode, ///
+    specificNode = specificSubstitutionNode,  ///
+    success = substitutionPass.run(generalNode, specificNode, generalContext, specificContext);
 
   if (success) {
     substitutionUnifies = true;

package/src/ruleNames.js

@@ -78,7 +78,6 @@ export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
 export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";
 export const STATEMENT_SUBSTITUTION_RULE_NAME = "statementSubstitution";
 export const REFERENCE_SUBSTITUTION_RULE_NAME = "referenceSubstitution";
-export const META_LEVEL_SUBSTITUTION_RULE_NAME = "metaLevelSubstitution";
 export const TYPE_PREFIX_DECLARATION_RULE_NAME = "typePrefixDeclaration";
 export const SIMPLE_TYPE_DECLARATION_RULE_NAME = "simpleTypeDeclaration";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";