occam-verify-cli 1.0.781 → 1.0.787

package/src/element/substitution/term.js

@@ -3,7 +3,7 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { simplify, instantiate } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { stripBracketsFromTerm } from "../../utilities/brackets";
 import { instantiateTermSubstitution } from "../../process/instantiate";
 import { termSubstitutionStringFromTermAndVariable } from "../../utilities/string";
@@ -212,14 +212,12 @@ export default define(class TermSubstitution extends Substitution {
 
     let termSubstitution;
 
-    simplify((context) => {
-      instantiate((context) => {
-        const termSubstitutionString = termSubstitutionStringFromTermAndVariable(term, variable),
-              string = termSubstitutionString,  ///
-              termSubstitutionNode = instantiateTermSubstitution(string, context);
+    instantiate((context) => {
+      const termSubstitutionString = termSubstitutionStringFromTermAndVariable(term, variable),
+            string = termSubstitutionString,  ///
+            termSubstitutionNode = instantiateTermSubstitution(string, context);
 
-        termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
-      }, context);
+      termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
     }, context);
 
     return termSubstitution;

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

package/src/utilities/context.js

@@ -90,22 +90,6 @@ export function nominally(innerFunction) {
   return innerFunction(context);
 }
 
-export function simplify(innerFunction, context) {
-  let contextExtraneousContext = isContextExtraneousContext(context);
-
-  while (contextExtraneousContext) {
-    context = context.getContext();
-
-    contextExtraneousContext = isContextExtraneousContext(context);
-  }
-
-  const ephemeralContext = EphemeralContext.fromNothing(context);
-
-  context = ephemeralContext; ///
-
-  return innerFunction(context);
-}
-
 export function serialise(innerFunction, context) {
   const ephemeralContext = context, ///
         ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
@@ -124,14 +108,14 @@ export function unserialise(innerFunction, json, context) {
   return innerFunction(json, context);
 }
 
-export async function asyncRestrict(innerFunction, metaLevelSubstitutions, context) {
+export async function asyncRestrict(innerFunction, assumptions, context) {
   if (context === undefined) {
-    context = metaLevelSubstitutions;  ///
+    context = assumptions;  ///
 
-    metaLevelSubstitutions = null;
+    assumptions = null;
   }
 
-  const proofContext = ProofContext.fromMetaLevelSubstitutions(metaLevelSubstitutions, context);
+  const proofContext = ProofContext.fromAssumptions(assumptions, context);
 
   context = proofContext;  ///
 
@@ -145,16 +129,3 @@ export async function asyncReconcile(innerFunction, context) {
 
   return await innerFunction(context);
 }
-
-function isContextExtraneousContext(context) {
-  const contextLiminalContext = (context instanceof LiminalContext),
-        contextEphemeralContext = (context instanceof EphemeralContext),
-        contextBranchingContext = (context instanceof BranchingContext),
-        contextSyntheticContext = (context instanceof SyntheticContext),
-        contextExtraneousContext = ( contextLiminalContext
-                                  || contextEphemeralContext
-                                  || contextBranchingContext
-                                  || contextSyntheticContext );
-
-  return contextExtraneousContext;
-}

package/src/utilities/element.js

@@ -3,8 +3,6 @@
 import elements from "../elements";
 
 import { baseTypeFromNothing } from "../utilities/type";
-import { simplify, instantiate,} from "../utilities/context";
-import { instantiateLabel, instantiateReference } from "../process/instantiate";
 import { equivalenceStringFromTerms,
          typeStringFromNominalTypeName,
          rulsStringFromLabelsPremisesAndConclusion,
@@ -348,11 +346,11 @@ export function metaLemmaFromMetaLemmaNode(metaLemmaNode, context) {
         label = labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         deduction = deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         suppositions = suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
-        metaLevelSubstitutions = metaLevelSubstitutionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        assumptions = assumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
         node = metaLemmaMetathoremNode, ///
         string = topLevelMetaAssertionString, ///
-        metaLemma = new MetaLemma(context, string, node, label, suppositions, deduction, proof, metaLevelSubstitutions);
+        metaLemma = new MetaLemma(context, string, node, label, suppositions, deduction, proof, assumptions);
 
   return metaLemma;
 }
@@ -437,20 +435,6 @@ export function conclusionFromConclusionNode(conclusionNode, context) {
   return conclusion;
 }
 
-export function assumptionFromAssumptionNode(assumptionNode, context) {
-  const { Assumption } = elements,
-        node = assumptionNode, ///
-        string = context.nodeAsString(node),
-        reference = referenceFromAssumptionNode(assumptionNode, context),
-        statement = statementFromAssumptionNode(assumptionNode, context);
-
-  context = null;
-
-  const assumption = new Assumption(context, string, node, reference, statement);
-
-  return assumption;
-}
-
 export function derivationFromDerivationNode(derivationNode, context) {
   const { Derivation } = elements,
         node = derivationNode,  ///
@@ -478,6 +462,20 @@ export function typePrefixFromTypePrefixNode(typePrefixNode, context) {
   return typePrefix;
 }
 
+export function assumptionFromAssumptionNode(assumptionNode, context) {
+  const { Assumption } = elements,
+        node = assumptionNode,  ///
+        string = context.nodeAsString(node),
+        reference = referenceFromAssumptionNode(assumptionNode, context),
+        statement = statementFromAssumptionNode(assumptionNode, context);
+
+  context = null;
+
+  const assumption = new Assumption(context, string, node, reference, statement);
+
+  return assumption;
+}
+
 export function constructorFromConstructorNode(constructorNode, context) {
   const { Constructor } = elements,
         node = constructorNode, ///
@@ -525,11 +523,11 @@ export function metatheoremFromMetatheoremNode(metatheoremNode, context) {
         label = labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         deduction = deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         suppositions = suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
-        metaLevelSubstitutions = metaLevelSubstitutionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        assumptions = assumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
         node = metaLemmaMetathoremNode, ///
         string = topLevelMetaAssertionString, ///
-        metatheorem = new Metatheorem(context, string, node, label, suppositions, deduction, proof, metaLevelSubstitutions);
+        metatheorem = new Metatheorem(context, string, node, label, suppositions, deduction, proof, assumptions);
 
   return metatheorem;
 }
@@ -788,21 +786,6 @@ export function statementSubstitutionFromStatementSubstitutionNode(statementSubs
   return statementSubstitution;
 }
 
-export function metaLevelSubstitutionFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context) {
-  const { MetaLevelSubstitution } = elements,
-        node = metaLevelSubstitutionNode,  ///
-        string = context.nodeAsString(node),
-        targetReference = targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
-        replacementStatement = replacementStatementFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
-        ephemeralContext = context.retrieveEphemeralContext();
-
-  context = ephemeralContext; ///
-
-  const metaLevelSubstitution = new MetaLevelSubstitution(context, string, node, targetReference, replacementStatement);
-
-  return metaLevelSubstitution;
-}
-
 export function constructorDeclarationFromConstructorDeclarationNode(constructorDeclarationNode, context) {
   const { ConstructorDeclaration } = elements,
         node = constructorDeclarationNode, ///
@@ -937,9 +920,10 @@ export function referenceFromStepNode(stepNode, context) {
   const referenceNode = stepNode.getReferenceNode();
 
   if (referenceNode !== null) {
-    const referenceString = context.nodeAsString(referenceNode);
+    const { Reference } = elements,
+          referenceString = context.nodeAsString(referenceNode);
 
-    reference = referenceFromReferenceString(referenceString, context);
+    reference = Reference.fromReferenceString(referenceString, context);
   }
 
   return reference;
@@ -1361,9 +1345,10 @@ export function metavariableFromReferenceNode(referenceNode, context) {
 }
 
 export function referenceFromMetavariableNode(metavariableNode, context) {
-  const metavariableString = context.nodeAsString(metavariableNode),
+  const { Reference } = elements,
+        metavariableString = context.nodeAsString(metavariableNode),
         referenceString = metavariableString, ///
-        reference = referenceFromReferenceString(referenceString, context);
+        reference = Reference.fromReferenceString(referenceString, context);
 
   return reference;
 }
@@ -1601,9 +1586,10 @@ export function proofFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, cont
 }
 
 export function labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
-  const labelNode = metaLemmaMetathoremNode.getLabelNode(),
+  const { Label } = elements,
+        labelNode = metaLemmaMetathoremNode.getLabelNode(),
         labelString = context.nodeAsString(labelNode),
-        label = labelFromLabelString(labelString, context);
+        label = Label.fromLabelString(labelString, context);
 
   return label;
 }
@@ -1724,9 +1710,10 @@ export function signatureFromJSatisfiesAssertionNode(sasisfiesAssertionNode, con
 }
 
 export function referenceFromJSatisfiesAssertionNode(sasisfiesAssertionNode, context) {
-  const referenceNode = sasisfiesAssertionNode.getReferenceNode(),
+  const { Reference } = elements,
+        referenceNode = sasisfiesAssertionNode.getReferenceNode(),
         referenceString = context.nodeAsString(referenceNode),
-        reference = referenceFromReferenceString(referenceString, context);
+        reference = Reference.fromReferenceString(referenceString, context);
 
   return reference;
 }
@@ -1813,6 +1800,12 @@ export function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationN
   return metaType;
 }
 
+export function assumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
+  const assumptions = [];
+
+  return assumptions;
+}
+
 export function provisionalFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
   const provisional = simpleTypeDeclarationNode.isProvisional();
 
@@ -1889,19 +1882,12 @@ export function metavariableFromMetavariableDeclarationNode(metavariableDeclarat
 }
 
 export function targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
-  const targetReferenceNode = referenceSubstitutionNode.getTargetReferenceNode(),
-        targetReferenceString = context.nodeAsString(targetReferenceNode),
-        targetRefernece = referenceFromReferenceString(targetReferenceString, context);
-
-  return targetRefernece;
-}
-
-export function targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context) {
-  const targetReferenceNode = metaLevelSubstitutionNode.getTargetReferenceNode(),
+  const { Reference } = elements,
+        targetReferenceNode = referenceSubstitutionNode.getTargetReferenceNode(),
         targetReferenceString = context.nodeAsString(targetReferenceNode),
-        targetRefernece = referenceFromReferenceString(targetReferenceString, context);
+        targetReference = Reference.fromReferenceString(targetReferenceString, context);
 
-  return targetRefernece;
+  return targetReference;
 }
 
 export function targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, context) {
@@ -1936,9 +1922,10 @@ export function frameSubstitutionFromStatementSubstitutionNode(statementSubstitu
 }
 
 export function replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
-  const replacementReferenceNode = referenceSubstitutionNode.getReplacementReferenceNode(),
+  const { Reference } = elements,
+        replacementReferenceNode = referenceSubstitutionNode.getReplacementReferenceNode(),
         replacementReferenceString = context.nodeAsString(replacementReferenceNode),
-        replacementReference = referenceFromReferenceString(replacementReferenceString, context);
+        replacementReference = Reference.fromReferenceString(replacementReferenceString, context);
 
   return replacementReference;
 }
@@ -1950,19 +1937,6 @@ export function replacementStatementFromStatementSubstitutionNode(statementSubst
   return replacementStatement;
 }
 
-export function replacementStatementFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context) {
-  const replacementStatementNode = metaLevelSubstitutionNode.getReplacementStatementNode(),
-        replacementStatement = statementFromStatementNode(replacementStatementNode, context);
-
-  return replacementStatement;
-}
-
-export function metaLevelSubstitutionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
-  const metaLevelSubstitutions = [];
-
-  return metaLevelSubstitutions;
-}
-
 export function termsFromTermNodes(termNodes, context) {
   const terms = termNodes.map((termNode) => {
     const term = termFromTermNode(termNode, context);
@@ -1986,8 +1960,9 @@ export function typesFromTypesNode(typesNode, context) {
 
 export function labelsFromLabelNodes(labelNodes, context) {
   const labels = labelNodes.map((labelNode) => {
-    const labelString = context.nodeAsString(labelNode),
-          label = labelFromLabelString(labelString, context);
+    const { Label } = elements,
+          labelString = context.nodeAsString(labelNode),
+          label = Label.fromLabelString(labelString, context);
 
     return label;
   });
@@ -2076,33 +2051,3 @@ export function stepsOrSubproofsFromSubDerivationNode(subDerivationNode, context
 
   return stepsOrSubproofs;
 }
-
-export function labelFromLabelString(labelString, context) {
-  let label;
-
-  simplify((context) => {
-    instantiate((context) => {
-      const string = labelString,  ///
-            labelNode = instantiateLabel(string, context);
-
-      label = labelFromLabelNode(labelNode, context);
-    }, context);
-  }, context);
-
-  return label;
-}
-
-export function referenceFromReferenceString(referenceString, context) {
-  let reference;
-
-  simplify((context) => {
-    instantiate((context) => {
-      const string = referenceString,  ///
-            referenceNode = instantiateReference(string, context);
-
-      reference = referenceFromReferenceNode(referenceNode, context);
-    }, context);
-  }, context);
-
-  return reference;
-}