occam-verify-cli 1.0.792 → 1.0.796

package/src/element/substitution/reference.js

@@ -70,6 +70,23 @@ export default define(class ReferenceSubstitution extends Substitution {
     return comparesToParameter;
   }
 
+  compareSubstitution(substitution) {
+    let substitutionCompares = false;
+
+    const substitutionReferenceSubstitution = (substitution instanceof ReferenceSubstitution);
+
+    if (substitutionReferenceSubstitution) {
+      const substitutionNode = substitution.getNode(),
+            substitutionNodeMatches = this.matchNode(substitutionNode);
+
+      if (substitutionNodeMatches) {
+        substitutionCompares = true;
+      }
+    }
+
+    return substitutionCompares;
+  }
+
   validate(generalContext, specificContext) {
     let referenceSubstitution = null;
 
@@ -199,6 +216,22 @@ export default define(class ReferenceSubstitution extends Substitution {
 
     return referenceSubstitution;
   }
+
+  static fromAssumptionAndMetaLevelAssumption(assumption, metaLevelAssumption, context) {
+    let referenceSubstitution;
+
+    instantiate((context) => {
+      const reference = metaLevelAssumption.getReference(),
+            metavariable = assumption.getMetavariable(),
+            referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
+            string = referenceSubstitutionString,  ///
+            referenceSubstitutionNode = instantiateReferenceSubstitution(string, context);
+
+      referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+    }, context);
+
+    return referenceSubstitution;
+  }
 });
 
 function targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {

package/src/element/substitution/statement.js

@@ -132,7 +132,11 @@ export default define(class StatementSubstitution extends Substitution {
           const replacementStatementValidates = this.validateReplacementStatement(generalContext, specificContext);
 
           if (replacementStatementValidates) {
-            validates = true;
+            const substitutionValidates = this.validateSubstitution(generalContext, specificContext);
+
+            if (substitutionValidates) {
+              validates = true;
+            }
           }
         }
 
@@ -155,6 +159,34 @@ export default define(class StatementSubstitution extends Substitution {
     return statementSubstitution;
   }
 
+  validateSubstitution(generalContext, specificContext) {
+    let substitutionValidates = true;
+
+    if (this.substitution !== null) {
+      const context = specificContext,  ///
+            substitutionString = this.substitution.getString(),
+            statementSubstitutionString = this.getString();
+
+      context.trace(`Validating the '${statementSubstitutionString}' statement substitution's '${substitutionString}' substitution...`);
+
+      specificContext = generalContext; ///
+
+      const substitution = this.substitution.validate(generalContext, specificContext);
+
+      if (substitution !== null) {
+        this.substitution = substitution;
+
+        substitutionValidates = true;
+      }
+
+      if (substitutionValidates) {
+        context.debug(`...validatewd the '${statementSubstitutionString}' statement substitution's '${substitutionString}' substitution.`);
+      }
+    }
+
+    return substitutionValidates;
+  }
+
   validateTargetStatement(generalContext, specificContext) {
     let targetStatementValidates = false;
 

package/src/element/topLevelMetaAssertion.js

@@ -3,27 +3,27 @@
 import { Element, asynchronousUtilities } from "occam-languages";
 
 import { asyncRestrict } from "../utilities/context";
-import { topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
+import { topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions } from "../utilities/string";
 import { labelFromJSON,
          labelToLabelJSON,
          deductionFromJSON,
-         assumptionsFromJSON,
          suppositionsFromJSON,
          deductionToDeductionJSON,
-         assumptionsToAssumptionsJSON,
-         suppositionsToSuppositionsJSON } from "../utilities/json";
+         metaLevelAssumptionsFromJSON,
+         suppositionsToSuppositionsJSON,
+         metaLevelAssumptionsToMetaLevelAssumptionsJSON } from "../utilities/json";
 
 const { asyncForwardsEvery } = asynchronousUtilities;
 
 export default class TopLevelMetaAssertion extends Element {
-  constructor(context, string, node, label, suppositions, deduction, proof, assumptions) {
+  constructor(context, string, node, label, suppositions, deduction, proof, metaLevelAssumptions) {
     super(context, string, node);
 
     this.label = label;
     this.suppositions = suppositions;
     this.deduction = deduction;
     this.proof = proof;
-    this.assumptions = assumptions;
+    this.metaLevelAssumptions = metaLevelAssumptions;
   }
 
   getLabel() {
@@ -42,8 +42,8 @@ export default class TopLevelMetaAssertion extends Element {
     return this.proof;
   }
 
-  getAssumptions() {
-    return this.assumptions;
+  getMetaLevelAssumptions() {
+    return this.metaLevelAssumptions;
   }
 
   getStatement() {
@@ -121,7 +121,7 @@ export default class TopLevelMetaAssertion extends Element {
           }
         }
       }
-    }, this.assumptions, context);
+    }, this.metaLevelAssumptions, 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),
-          assumptionsJSON = assumptionsToAssumptionsJSON(this.assumptions),
+          metaLevelAssumptionsJSON = metaLevelAssumptionsToMetaLevelAssumptionsJSON(this.metaLevelAssumptions),
           label = labelJSON,  ///
           deduction = deductionJSON,  ///
           suppositions = suppositionsJSON,  ///
-          assumptions = assumptionsJSON,  ///
+          metaLevelAssumptions = metaLevelAssumptionsJSON,  ///
           json = {
             label,
             deduction,
             suppositions,
-            assumptions
+            metaLevelAssumptions
           };
 
     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),
-          assumptions = assumptionsFromJSON(json, context),
+          metaLevelAssumptions = metaLevelAssumptionsFromJSON(json, context),
           node = null,
           proof = null,
-          string = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
-          topLevelMetaAssertion = new Class(context, string, node, label, suppositions, deduction, proof, assumptions);
+          string = topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions(label, suppositions, deduction, metaLevelAssumptions),
+          topLevelMetaAssertion = new Class(context, string, node, label, suppositions, deduction, proof, metaLevelAssumptions);
 
     return topLevelMetaAssertion;
   }

package/src/node/assumption/metaLevel.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-languages";
+
+import { REFERENCE_RULE_NAME, STATEMENT_RULE_NAME } from "../../ruleNames";
+
+export default class MetaLevelAssumptionpNode extends NonTerminalNode {
+  getReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          referenceNode = this.getNodeByRuleName(ruleName);
+
+    return referenceNode;
+  }
+
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaLevelAssumptionpNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/assumption.js

@@ -2,16 +2,9 @@
 
 import { NonTerminalNode } from "occam-languages";
 
-import { STATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME } from "../ruleNames";
+import { METAVARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
 
 export default class AssumptionpNode extends NonTerminalNode {
-  getStatementNode() {
-    const ruleName = STATEMENT_RULE_NAME,
-          statementNode = this.getNodeByRuleName(ruleName);
-
-    return statementNode;
-  }
-
   getMetavariableNode() {
     const ruleName = METAVARIABLE_RULE_NAME,
           metavariableNode = this.getNodeByRuleName(ruleName);
@@ -19,5 +12,12 @@ export default class AssumptionpNode extends NonTerminalNode {
     return metavariableNode;
   }
 
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(AssumptionpNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/nonTerminalNodeMap.js

@@ -75,6 +75,7 @@ import SatisfiesAssertionNode from "./node/assertion/satisfies";
 import ParenthesisedLabelsNode from "./node/parenthesisedLabels"
 import PropertyDeclarationNode from "./node/declaration/property";
 import VariableDeclarationNode from "./node/declaration/variable";
+import MetaLevelAssumptionpNode from "./node/assumption/metaLevel";
 import SimpleTypeDeclarationNode from "./node/declaration/simpleType";
 import CombinatorDeclarationNode from "./node/declaration/combinator";
 import ReferenceSubstitutionNode from "./node/substitution/reference";
@@ -160,6 +161,7 @@ import {
   PARENTHESISED_LABELS_RULE_NAME,
   PROPERTY_DECLARATION_RULE_NAME,
   VARIABLE_DECLARATION_RULE_NAME,
+  META_LEVEL_ASSUMPTION_RULE_NAME,
   COMBINATOR_DECLARATION_RULE_NAME,
   REFERENCE_SUBSTITUTION_RULE_NAME,
   STATEMENT_SUBSTITUTION_RULE_NAME,
@@ -245,6 +247,7 @@ const NonTerminalNodeMap = {
   [PARENTHESISED_LABELS_RULE_NAME]: ParenthesisedLabelsNode,
   [VARIABLE_DECLARATION_RULE_NAME]: VariableDeclarationNode,
   [PROPERTY_DECLARATION_RULE_NAME]: PropertyDeclarationNode,
+  [META_LEVEL_ASSUMPTION_RULE_NAME]: MetaLevelAssumptionpNode,
   [COMBINATOR_DECLARATION_RULE_NAME]: CombinatorDeclarationNode,
   [STATEMENT_SUBSTITUTION_RULE_NAME]: StatementSubstitutionNode,
   [REFERENCE_SUBSTITUTION_RULE_NAME]: ReferenceSubstitutionNode,

package/src/preamble.js

@@ -50,6 +50,7 @@ import PropertyAssertion from "./element/assertion/property";
 import ProcedureReference from "./element/procedureReference";
 import ContainedAssertion from "./element/assertion/contained";
 import SatisfiesAssertion from "./element/assertion/satisfies";
+import MetaLevelAssumption from "./element/assumption/metaLevel";
 import VariableDeclaration from "./element/declaration/variable";
 import BracketedCombinator from "./element/combinator/bracketed";
 import BracketedConstructor from "./element/constructor/bracketed";

package/src/process/instantiate.js

@@ -33,6 +33,7 @@ import { TERM_RULE_NAME,
          PROCEDURE_REFERENCE_RULE_NAME,
          CONTAINED_ASSERTION_RULE_NAME,
          SATISFIES_ASSERTION_RULE_NAME,
+         META_LEVEL_ASSUMPTION_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME,
          REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
@@ -68,6 +69,7 @@ const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       procedureReferencelaceholderRule = ruleFromRuleName(PROCEDURE_REFERENCE_RULE_NAME),
       containedAssertionPlaceholderRule = ruleFromRuleName(CONTAINED_ASSERTION_RULE_NAME),
       satisfiesAssertionPlaceholderRule = ruleFromRuleName(SATISFIES_ASSERTION_RULE_NAME),
+      metaLevelAssumptionPlaceholderRule = ruleFromRuleName(META_LEVEL_ASSUMPTION_RULE_NAME),
       statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
       referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
 
@@ -155,6 +157,8 @@ export function instantiateContainedAssertion(string, context) { return instanti
 
 export function instantiateSatisfiesAssertion(string, context) { return instantiate(satisfiesAssertionPlaceholderRule, string, context); }
 
+export function instantiateMetaLevelAssumption(string, context) { return instantiate(metaLevelAssumptionPlaceholderRule, string, context); }
+
 export function instantiateStatementSubstitution(string, context) { return instantiate(statementSubstitutionPlaceholderRule, string, context); }
 
 export function instantiateReferenceSubstitution(string, context) { return instantiate(referenceSubstitutionPlaceholderRule, string, context); }

package/src/process/unify.js

@@ -17,6 +17,7 @@ const typeNodeQuery = nodeQuery("/type"),
       metavariableNodeQuery = nodeQuery("/metavariable"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
+      referenceMetavariableNodeQuery = nodeQuery("/reference/metavariable!"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       assumptionMetavariableNodeQuery = nodeQuery("/assumption/metavariable!");
 
@@ -29,21 +30,24 @@ class MetaLevelPass extends ZipPassBase {
         let success = false;
 
         let context,
+            reference,
             metavariableNode;
 
         context = generalContext; ///
 
         metavariableNode = generalAssumptionMetavariableNode;  ///
 
-        const metavariableName = metavariableNode.getMetavariableName(),
-              metavariable = context.findMetavariableByMetavariableName(metavariableName);
+        reference = context.findReferenceByMetavariableNode(metavariableNode);
+
+        const metavariable = reference.getMetavariable();
 
         context = specificContext;  ///
 
         metavariableNode = specificAssumptionMetavariableNode; ///
 
-        const reference = context.findReferenceByMetavariableNode(metavariableNode),
-              referenceUnifies = metavariable.unifyReference(reference, generalContext, specificContext);
+        reference = context.findReferenceByMetavariableNode(metavariableNode);
+
+        const referenceUnifies = metavariable.unifyReference(reference, generalContext, specificContext);
 
         if (referenceUnifies) {
           success = true;
@@ -181,56 +185,31 @@ class AssumptionPass extends ZipPass {
     },
     {
       generalNodeQuery: metavariableNodeQuery,
-      specificNodeQuery: metavariableNodeQuery,
-      run: (generalMetavariableNode, specificMetavariableNode, generalContext, specificContext) => {
+      specificNodeQuery: referenceMetavariableNodeQuery,
+      run: (generalMetavariableNode, specificReferenceMetavariableNode, generalContext, specificContext) => {
         let success = false;
 
         let context,
+            reference,
             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();
+        reference = context.findReferenceByMetavariableNode(metavariableNode);
 
-        let context;
+        const metavariable = reference.getMetavariable();
 
-        context = generalContext; ///
+        context = specificContext;  ///
 
-        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
+        metavariableNode = specificReferenceMetavariableNode; ///
 
-        context = specificContext;  ///
+        reference = context.findReferenceByMetavariableNode(metavariableNode);
 
-        const term = context.findTermByTermNode(termNode),
-              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+        const referenceUnifies = metavariable.unifyReference(reference, generalContext, specificContext);
 
-        if (termUnifies) {
+        if (referenceUnifies) {
           success = true;
         }
 

package/src/ruleNames.js

@@ -75,6 +75,7 @@ export const SATISFIES_ASSERTION_RULE_NAME = "satisfiesAssertion";
 export const PARENTHESISED_LABELS_RULE_NAME = "parenthesisedLabels";
 export const PROPERTY_DECLARATION_RULE_NAME = "propertyDeclaration";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
+export const META_LEVEL_ASSUMPTION_RULE_NAME = "metaLevelAssumption";
 export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";
 export const STATEMENT_SUBSTITUTION_RULE_NAME = "statementSubstitution";
 export const REFERENCE_SUBSTITUTION_RULE_NAME = "referenceSubstitution";

package/src/utilities/context.js

@@ -114,14 +114,14 @@ export function unserialise(innerFunction, json, context) {
   return innerFunction(json, context);
 }
 
-export async function asyncRestrict(innerFunction, assumptions, context) {
+export async function asyncRestrict(innerFunction, metaLevelAssumptions, context) {
   if (context === undefined) {
-    context = assumptions;  ///
+    context = metaLevelAssumptions;  ///
 
-    assumptions = null;
+    metaLevelAssumptions = null;
   }
 
-  const proofContext = ProofContext.fromAssumptions(assumptions, context);
+  const proofContext = ProofContext.fromMetaLevelAssumptions(metaLevelAssumptions, context);
 
   context = proofContext;  ///
 

package/src/utilities/element.js

@@ -10,7 +10,7 @@ import { equivalenceStringFromTerms,
          subproofStringFromSuppositionsAndSubDerivation,
          procedureCallStringFromProcedureReferenceAndParameters,
          topLevelAssertionStringFromLabelsSuppositionsAndDeduction,
-         topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
+         topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions } from "../utilities/string";
 
 export function typeFromTypeNode(typeNode, context) {
   let type;
@@ -346,11 +346,11 @@ export function metaLemmaFromMetaLemmaNode(metaLemmaNode, context) {
         label = labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         deduction = deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         suppositions = suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
-        assumptions = assumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
-        topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
+        metaLevelAssumptions = metaLevelAssumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions(label, suppositions, deduction, metaLevelAssumptions),
         node = metaLemmaMetathoremNode, ///
         string = topLevelMetaAssertionString, ///
-        metaLemma = new MetaLemma(context, string, node, label, suppositions, deduction, proof, assumptions);
+        metaLemma = new MetaLemma(context, string, node, label, suppositions, deduction, proof, metaLevelAssumptions);
 
   return metaLemma;
 }
@@ -467,11 +467,8 @@ export function assumptionFromAssumptionNode(assumptionNode, context) {
         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);
+        statement = statementFromAssumptionNode(assumptionNode, context),
+        assumption = new Assumption(context, string, node, reference, statement);
 
   return assumption;
 }
@@ -523,11 +520,11 @@ export function metatheoremFromMetatheoremNode(metatheoremNode, context) {
         label = labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         deduction = deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
         suppositions = suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
-        assumptions = assumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
-        topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
+        metaLevelAssumptions = metaLevelAssumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions(label, suppositions, deduction, metaLevelAssumptions),
         node = metaLemmaMetathoremNode, ///
         string = topLevelMetaAssertionString, ///
-        metatheorem = new Metatheorem(context, string, node, label, suppositions, deduction, proof, assumptions);
+        metatheorem = new Metatheorem(context, string, node, label, suppositions, deduction, proof, metaLevelAssumptions);
 
   return metatheorem;
 }
@@ -730,6 +727,17 @@ export function variableDeclarationFromVariableDeclarationNode(variableDeclarati
   return variableDeclaration;
 }
 
+export function metaLevelAssumptionFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context) {
+  const { MetaLevelAssumption } = elements,
+        node = metaLevelAssumptionNode,  ///
+        string = context.nodeAsString(node),
+        reference = referenceFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context),
+        statement = statementFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context),
+        metaLevelAssumption = new MetaLevelAssumption(context, string, node, reference, statement);
+
+  return metaLevelAssumption;
+}
+
 export function typePrefixDeclarationFromTypePrefixDeclarationNode(typePrefixDeclarationNode, context) {
   const { TypePrefixDeclaration } = elements,
         node = typePrefixDeclarationNode, ///
@@ -1245,13 +1253,8 @@ export function statementFromConclusionNode(conclusinoNode, context) {
 }
 
 export function statementFromAssumptionNode(assumptionNode, context) {
-  let statement;
-
-  const statementNode = assumptionNode.getStatementNode();
-
-  if (statementNode !== null) {
-    statement = statementFromStatementNode(statementNode, context);
-  }
+  const statementNode = assumptionNode.getStatementNode(),
+        statement = statementFromStatementNode(statementNode, context);
 
   return statement;
 }
@@ -1725,6 +1728,22 @@ export function targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, cont
   return targetFrame;
 }
 
+export function statementFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context) {
+  const statementNode = metaLevelAssumptionNode.getStatementNode(),
+        statement = statementFromStatementNode(statementNode, context);
+
+  return statement;
+}
+
+export function referenceFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context) {
+  const { Reference } = elements,
+        referenceNode = metaLevelAssumptionNode.getReferenceNode(),
+        referenceString = context.nodeAsString(referenceNode),
+        reference = Reference.fromReferenceString(referenceString, context);
+
+  return reference;
+}
+
 export function suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
   const suppositionNodes = topLevelAsssertionNode.getSuppositionNodes(),
         suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);
@@ -1800,12 +1819,6 @@ export function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationN
   return metaType;
 }
 
-export function assumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
-  const assumptions = [];
-
-  return assumptions;
-}
-
 export function provisionalFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
   const provisional = simpleTypeDeclarationNode.isProvisional();
 
@@ -1937,6 +1950,12 @@ export function replacementStatementFromStatementSubstitutionNode(statementSubst
   return replacementStatement;
 }
 
+export function metaLevelAssumptionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
+  const metaLevelAssumptions = [];
+
+  return metaLevelAssumptions;
+}
+
 export function termsFromTermNodes(termNodes, context) {
   const terms = termNodes.map((termNode) => {
     const term = termFromTermNode(termNode, context);

package/src/utilities/json.js

@@ -565,7 +565,7 @@ export function assumptionsFromJSON(json, context) {
   let { assumptions } = json;
 
   const { Assumption } = elements,
-        assumptionsJSON = assumptions; ///
+    assumptionsJSON = assumptions; ///
 
   assumptions = assumptionsJSON.map((assumptionJSON) => {
     const json = assumptionJSON,  ///
@@ -702,6 +702,22 @@ export function propertyRelationsFromJSON(json, context) {
   return propertyRelations;
 }
 
+export function metaLevelAssumptionsFromJSON(json, context) {
+  let { metaLevelAssumptions } = json;
+
+  const { MetaLevelAssumption } = elements,
+        metaLevelAssumptionsJSON = metaLevelAssumptions; ///
+
+  metaLevelAssumptions = metaLevelAssumptionsJSON.map((metaLevelAssumptionJSON) => {
+    const json = metaLevelAssumptionJSON,  ///
+          metaLevelAssumption = MetaLevelAssumption.fromJSON(json, context);
+
+    return metaLevelAssumption;
+  });
+
+  return metaLevelAssumptions;
+}
+
 export function nameToNameJSON(name) {
   const nameJSON = name;  ///
 
@@ -1120,6 +1136,16 @@ export function propertyRelationsToPropertyRelationsJSON(propertyRelations) {
   return propertyRelationsJSON;
 }
 
+export function metaLevelAssumptionsToMetaLevelAssumptionsJSON(metaLevelAssumptions) {
+  const metaLevelAssumptionsJSON = metaLevelAssumptions.map((metaLevelAssumption) => {
+    const metaLevelAssumptionJSON = metaLevelAssumption.toJSON();
+
+    return metaLevelAssumptionJSON;
+  });
+
+  return metaLevelAssumptionsJSON;
+}
+
 function findTypeByName(name, context) {
   const typeName = name,  ///
         type = context.findTypeByTypeName(typeName);