occam-verify-cli 1.0.448 → 1.0.472

package/src/utilities/element.js

@@ -2,15 +2,17 @@
 
 import elements from "../elements";
 
+import { literally } from "../utilities/context";
 import { baseTypeFromNothing } from "../types";
 import { instantiateReference } from "../process/instantiate";
+import { findMetaTypeByMetaTypeName } from "../metaTypes";
 import { equivalenceStringFromTerms,
          rulsStringFromLabelsPremisesAndConclusion,
+         sectionStringFromHypothesesTopLevelAssertion,
          subproofStringFromSuppositionsAndSubDerivation,
          procedureCallStringFromProcedureReferenceAndParameters,
-         sectionStringFromHypothesesAxiomLemmaTheoremAndConjecture,
-         metaLemmaMetatheoremStringFromLabelSuppositionsAndDeduction,
-         axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction } from "../utilities/string";
+         topLevelAssertionStringFromLabelsSuppositionsAndDeduction,
+         topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
 
 export function typeFromTypeNode(typeNode, context) {
   let type;
@@ -42,11 +44,8 @@ export function termFromTermNode(termNode, context) {
   const { Term } = elements,
         node = termNode,  ///
         string = context.nodeAsString(node),
-        type = null;
-
-  context = null;
-
-  const term = new Term(context, string, node, type);
+        type = typeFromTermNode(termNode, context),
+        term = new Term(context, string, node, type);
 
   return term;
 }
@@ -98,16 +97,16 @@ export function errorFromErrorNode(errorNode, context) {
 
 export function lemmaFromLemmaNode(lemmaNode, context) {
   const { Lemma } = elements,
-        axiomLemmaTheoremConjectureNode = lemmaNode,  ///
-        proof = proofFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        labels = labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        deduction = deductionFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        suppositions = suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        signature = signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        hypotheses = [],
-        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        topLevelAsssertionNode = lemmaNode,  ///
+        proof = proofFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        labels = labelsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        deduction = deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        hypotheses = hypothesesFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = lemmaNode, ///
-        string = axiomLemmaTheoremConjectureString, ///
+        string = topLevelAsssertionString, ///
         lemma = new Lemma(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
   return lemma;
@@ -115,10 +114,10 @@ export function lemmaFromLemmaNode(lemmaNode, context) {
 
 export function frameFromFrameNode(frameNode, context) {
   const { Frame } = elements,
-    node = frameNode, ///
-    string = context.nodeAsString(node),
-    assumptions = assumptionsFromFrameNode(frameNode, context),
-    frame = new Frame(context, string, node, assumptions);
+        node = frameNode, ///
+        string = context.nodeAsString(node),
+        assumptions = assumptionsFromFrameNode(frameNode, context),
+        frame = new Frame(context, string, node, assumptions);
 
   return frame;
 }
@@ -135,16 +134,16 @@ export function proofFromProofNode(proofNode, context) {
 
 export function axiomFromAxiomNode(axiomNode, context) {
   const { Axiom } = elements,
-        axiomLemmaTheoremConjectureNode = axiomNode,  ///
-        proof = null,
-        labels = labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        deduction = deductionFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        suppositions = suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        signature = signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
+        topLevelAsssertionNode = axiomNode,  ///
+        proof = proofFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        labels = labelsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        deduction = deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         hypotheses = [],
-        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = axiomNode, ///
-        string = axiomLemmaTheoremConjectureString, ///
+        string = topLevelAsssertionString, ///
         axiom = new Axiom(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
   return axiom;
@@ -157,7 +156,7 @@ export function sectionFromSectionNode(sectionNode, context) {
         lemma = lemmaFromSectionNode(sectionNode, context),
         theorem = theoremFromSectionNode(sectionNode, context),
         conjecture = conjectureFromSectionNode(sectionNode, context),
-        sectionString = sectionStringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context),
+        sectionString = sectionStringFromHypothesesTopLevelAssertion(hypotheses, axiom, lemma, theorem, conjecture),
         node = sectionNode, ///
         string = sectionString, ///
         section = new Section(context, string, node, hypotheses, axiom, lemma, theorem, conjecture);
@@ -178,53 +177,36 @@ export function premiseFromPremiseNode(premiseNode, context) {
 
 export function theoremFromTheoremNode(theoremNode, context) {
   const { Theorem } = elements,
-        axiomLemmaTheoremConjectureNode = theoremNode,  ///
-        proof = proofFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        labels = labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        deduction = deductionFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        suppositions = suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        signature = signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
+        topLevelAsssertionNode = theoremNode,  ///
+        proof = proofFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        labels = labelsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        deduction = deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         hypotheses = [],
-        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = theoremNode, ///
-        string = axiomLemmaTheoremConjectureString, ///
+        string = topLevelAsssertionString, ///
         theorem = new Theorem(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
   return theorem;
 }
 
-export function equalityFromEqualityNode(equalityNode, context) {
-  const { Equality } = elements,
-        node = equalityNode,  ///
-        string = context.nodeAsString(node),
-        leftTermNode = equalityNode.getLeftTermNode(),
-        rightTermNode = equalityNode.getRightTermNode(),
-        leftTerm = termFromTermNode(leftTermNode, context),
-        rightTerm = termFromTermNode(rightTermNode, context),
-        equality = new Equality(string, leftTerm, rightTerm);
-
-  return equality;
-}
-
 export function metaTypeFromMetaTypeNode(metaTypeNode, context) {
-  const { MetaType } = elements,
-        node = metaTypeNode,  ///
-        string = context.nodeAsString(node),
-        metaTypeName = metaTypeNode.getMetaTypeName(),
-        name = metaTypeName,  ///
-        metaType = new MetaType(context, string, node, name);
+  const metaTypeName = metaTypeNode.getMetaTypeName(),
+        metaType = findMetaTypeByMetaTypeName(metaTypeName);
 
   return metaType;
 }
 
 export function propertyFromPropertyNode(propertyNode, context) {
   const { Property } = elements,
-    node = propertyNode, ///
-    string = context.nodeAsString(node),
-    propertyName = propertyNode.getPropertyName(),
-    nominalTypeName = null,
-    name = propertyName,  ///
-    property = new Property(context, string, node, name, nominalTypeName);
+        node = propertyNode, ///
+        string = context.nodeAsString(node),
+        propertyName = propertyNode.getPropertyName(),
+        nominalTypeName = null,
+        name = propertyName,  ///
+        property = new Property(context, string, node, name, nominalTypeName);
 
   return property;
 }
@@ -283,11 +265,8 @@ export function deductionFromDeductionNode(deductionNode, context) {
 export function statementFromStatementNode(statementNode, context) {
   const { Statement } = elements,
         node = statementNode, ///
-        string = context.nodeAsString(node);
-
-  context = null;
-
-  const statement = new Statement(context, string, node);
+        string = context.nodeAsString(node),
+        statement = new Statement(context, string, node);
 
   return statement;
 }
@@ -326,13 +305,14 @@ export function judgementFromJudgementNode(judgementNode, context) {
 export function metaLemmaFromMetaLemmaNode(metaLemmaNode, context) {
   const { MetaLemma } = elements,
         metaLemmaMetathoremNode = metaLemmaNode,  ///
-        proof = proofFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        label = labelFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        deduction = deductionFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        suppositions = suppositionsFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
+        proof = proofFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        label = labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        deduction = deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        suppositions = suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
         substitutions = null,
         node = metaLemmaNode, ///
-        string = metaLemmaMetatheoremStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
+        string = topLevelMetaAssertionString, ///
         metaLemma = new MetaLemma(context, string, node, label, suppositions, deduction, proof, substitutions);
 
   return metaLemma;
@@ -342,9 +322,9 @@ export function parameterFromParameterNode(parameterNode, context) {
   const { Parameter } = elements,
         node = parameterNode, ///
         string = context.nodeAsString(node),
-        parameterName = parameterNode.getParameterName(),
-        name = parameterName,  ///
-        parameter = new Parameter(context, string, node, name);
+        name = parameterNode.getName(),
+        identifier = parameterNode.getIdentifier(),
+        parameter = new Parameter(context, string, node, name, identifier);
 
   return parameter;
 }
@@ -361,16 +341,16 @@ export function hypothesisFromHypothesisNode(hypotheseNode, context) {
 
 export function conjectureFromConjectureNode(conjectureNode, context) {
   const { Conjecture } = elements,
-        axiomLemmaTheoremConjectureNode = conjectureNode,  ///
-        proof = proofFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        labels = labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        deduction = deductionFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        suppositions = suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        signature = signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
+        topLevelAsssertionNode = conjectureNode,  ///
+        proof = proofFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        labels = labelsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        deduction = deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         hypotheses = [],
-        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = conjectureNode, ///
-        string = axiomLemmaTheoremConjectureString, ///
+        string = topLevelAsssertionString, ///
         conjecture = new Conjecture(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
   return conjecture;
@@ -396,16 +376,6 @@ export function conclusionFromConclusionNode(conclusionNode, context) {
   return conclusion;
 }
 
-export function conclusinoFromConclusionNode(conclusinoNode, context) {
-  const { Conclusion } = elements,
-        node = conclusinoNode, ///
-        string = context.nodeAsString(node),
-        statement = statementFromConclusionNode(conclusinoNode, context),
-        conclusino = new Conclusion(context, string, node, statement);
-
-  return conclusino;
-}
-
 export function assumptionFromAssumptionNode(assumptionNode, context) {
   const { Assumption } = elements,
         node = assumptionNode, ///
@@ -438,41 +408,6 @@ export function typePrefixFromTypePrefixNode(typePrefixNode, context) {
   return typePrefix;
 }
 
-export function metatheoremFromMetaLemmaNode(metatheoremNode, context) {
-  const { Metatehorem } = elements,
-        metaLemmaMetathoremNode = metatheoremNode,  ///
-        proof = proofFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        label = labelFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        deduction = deductionFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        suppositions = suppositionsFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        substitutions = null,
-        node = metaLemmaNode, ///
-        string = metaLemmaMetatheoremStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
-        metatheorem = new Metatehorem(context, string, node, label, suppositions, deduction, proof, substitutions);
-
-  return metatheorem;
-}
-
-export function referenceFromMetavariableNode(metavariableNode, context) {
-  const metavariableString = context.nodeAsString(metavariableNode),
-        referenceString = metavariableString, ///
-        string = referenceString,  ///
-        referenceNode = instantiateReference(string, context),
-        reference = referenceFromReferenceNode(referenceNode, context);
-
-  return reference;
-}
-
-export function hyppothesisFromHypothesisNode(hypothesisNode, context) {
-  const { Hypothesis } = elements,
-        node = hypothesisNode, ///
-        string = context.nodeAsString(node),
-        statement = statementFromHypothesisNode(hypothesisNode, context),
-        hypothesis = new Hypothesis(context, string, node, statement);
-
-  return hypothesis
-}
-
 export function constructorFromConstructorNode(constructorNode, context) {
   const { Constructor } = elements,
         node = constructorNode, ///
@@ -505,10 +440,20 @@ export function equivalenceFromEquivalenceNode(equivalenceNode, context) {
   return equivalence;
 }
 
-export function nameFromProcedureReferenceNode(procedureReferenceNode, context) {
-  const name = procedureReferenceNode.getName();
+export function metatheoremFromMetatheoremNode(metatheoremNode, context) {
+  const { Metatehorem } = elements,
+        metaLemmaMetathoremNode = metatheoremNode,  ///
+        proof = proofFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        label = labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        deduction = deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        suppositions = suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
+        substitutions = null,
+        node = metaLemmaNode, ///
+        string = topLevelMetaAssertionString, ///
+        metatheorem = new Metatehorem(context, string, node, label, suppositions, deduction, proof, substitutions);
 
-  return name;
+  return metatheorem;
 }
 
 export function metavariableFromMetavariableNode(metavariableNode, context) {
@@ -566,18 +511,6 @@ export function stepsOrSubproofFromStepOrSubproofNode(stepOrSubproofNode, contex
   return stepOrSubproof;
 }
 
-export function prefixedFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
-  const prefixed = simpleTypeDeclarationNode.isPrefixed();
-
-  return prefixed;
-}
-
-export function prefixedFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
-  const prefixed = complexTypeDeclarationNode.isPrefixed();
-
-  return prefixed;
-}
-
 export function definedAssertionFromDefinedAssertionNode(definedAssertionNode, context) {
   const { DefinedAssertion } = elements,
         node = definedAssertionNode,  ///
@@ -605,9 +538,9 @@ export function termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, c
   const { TermSubstitution } = elements,
         node = termSubstitutionNode,  ///
         string = context.nodeAsString(node),
-        term = termFromTermSubstitutionNode(termSubstitutionNode, context),
-        variable = variableFromTermSubstitutionNode(termSubstitutionNode, context),
-        termSubstitution = new TermSubstitution(context, string, node, term, variable);
+        targetTerm = targetTermFromTermSubstitutionNode(termSubstitutionNode, context),
+        replacementTerm = replacementTermFromTermSubstitutionNode(termSubstitutionNode, context),
+        termSubstitution = new TermSubstitution(context, string, node, targetTerm, replacementTerm);
 
   return termSubstitution;
 }
@@ -616,9 +549,9 @@ export function frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode
   const { FrameSubstitution } = elements,
         node = frameSubstitutionNode,  ///
         string = context.nodeAsString(node),
-        frame = frameFromFrameSubstitutionNode(frameSubstitutionNode, context),
-        metavariable = metavariableFromFrameSubstitutionNode(frameSubstitutionNode, context),
-        frameSubstitution = new FrameSubstitution(context, string, node, frame, metavariable);
+        targetFrame = targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
+        replacementFrame = replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
+        frameSubstitution = new FrameSubstitution(context, string, node, targetFrame, replacementFrame);
 
   return frameSubstitution;
 }
@@ -673,17 +606,26 @@ export function procedureReferenceFromProcedureReferenceNode(procedureReferenceN
         node = procedureReferenceNode,  ///
         string = context.nodeAsString(node),
         name = nameFromProcedureReferenceNode(procedureReferenceNode, context),
-        variableDeclaration = new ProcedureReference(context, string, node, name);
+        procedureDeclaration = new ProcedureReference(context, string, node, name);
 
-  return variableDeclaration;
+  return procedureDeclaration;
 }
 
 export function variableDeclarationFromVariableDeclarationNode(variableDeclarationNode, context) {
   const { VariableDeclaration } = elements,
         node = variableDeclarationNode,  ///
         string = context.nodeAsString(node),
-        variable = variableFromVariableNode(variableDeclarationNode, context),
-        variableDeclaration = new VariableDeclaration(context, string, node, variable);
+        typeNode = variableDeclarationNode.getTypeNode(),
+        provisional = variableDeclarationNode.isProvisional(),
+        variableNode = variableDeclarationNode.getVariableNode(),
+        type = typeFromTypeNode(typeNode, context),
+        variable = variableFromVariableNode(variableNode, context);
+
+  type.setProvisional(provisional);
+
+  variable.setType(type);
+
+  const variableDeclaration = new VariableDeclaration(context, string, node, variable);
 
   return variableDeclaration;
 }
@@ -719,30 +661,35 @@ export function simpleTypeDeclarationFromSimpleTypeDeclarationNode(simpleTypeDec
   return simpleTypeDeclaration;
 }
 
-export function statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context) {
-  const { StatementSubstitution } = elements,
-        node = statementSubstitutionNode,  ///
-        string = context.nodeAsString(node),
-        resolved = true,
-        statement = null,
-        metavariable = null,
-        substitution = null,
-        statementSubstitution = new StatementSubstitution(context, string, node, resolved, statement, metavariable, substitution);
-
-  return statementSubstitution;
-}
-
 export function referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
   const { ReferenceSubstitution } = elements,
         node = referenceSubstitutionNode,  ///
         string = context.nodeAsString(node),
-        reference = referenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
-        metavariable = metavariableFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
-        referenceSubstitution = new ReferenceSubstitution(context, string, node, reference, metavariable);
+        targetReference = targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
+        replacementReference = replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
+        referenceSubstitution = new ReferenceSubstitution(context, string, node, targetReference, replacementReference);
 
   return referenceSubstitution;
 }
 
+export function statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, substitution, context) {
+  if (context === undefined) {
+    context = substitution; ///
+
+    substitution = null;
+  }
+
+  const { StatementSubstitution } = elements,
+        node = statementSubstitutionNode,  ///
+        string = context.nodeAsString(node),
+        resolved = resolvedFromStatementSubstitutionNode(statementSubstitutionNode, substitution, context),
+        targetStatement = targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, context),
+        replacementStatement = replacementStatementFromStatementSubstitutionNode(statementSubstitutionNode, context),
+        statementSubstitution = new StatementSubstitution(context, string, node, resolved, substitution, targetStatement, replacementStatement);
+
+  return statementSubstitution;
+}
+
 export function constructorDeclarationFromConstructorDeclarationNode(constructorDeclarationNode, context) {
   const { ConstructorDeclaration } = elements,
         node = constructorDeclarationNode, ///
@@ -778,6 +725,12 @@ export function metavariableDeclarationFromMetavariableDeclarationNode(metavaria
   return metavariableDeclaration;
 }
 
+export function typeFromTermNode(termNode, context) {
+  const type = null;
+
+  return type;
+}
+
 export function proofFromRuleNode(ruleNode, context) {
   let proof = null;
 
@@ -814,18 +767,6 @@ export function lemmaFromSectionNode(sectionNode, context) {
   return lemma;
 }
 
-export function variableFromTermNode(termNode, context) {
-  let variable = null;
-
-  const variableNode = termNode.getVariableNode();
-
-  if (variableNode !== null) {
-    variable = variableFromVariableNode(variableNode, context);
-  }
-
-  return variable;
-}
-
 export function statementFromStepNode(stepNode, context) {
   let statement = null;
 
@@ -946,18 +887,6 @@ export function conjectureFromSectionNode(sectionNode, context) {
   return conjecture;
 }
 
-export function conclusionFromPremiseNode(premiseNode, context) {
-  let conclusion = null;
-
-  const conclusionNode = premiseNode.getConclusionNode();
-
-  if (conclusionNode !== null) {
-    conclusion = conclusionFromConclusionNode(conclusionNode, context);
-  }
-
-  return conclusion;
-}
-
 export function termFromTypeAssertionNode(typeAssertionNode, context) {
   let term = null;
 
@@ -982,18 +911,6 @@ export function typeFromTypeAssertionNode(typeAssertionNode, context) {
   return type;
 }
 
-export function metavariableFromFrameNode(frameNode, context) {
-  let metavariable = null;
-
-  const metavariableNode = frameNode.getMetavariableNode();
-
-  if (metavariableNode !== null) {
-    metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-  }
-
-  return metavariable;
-}
-
 export function identifierFromVarialbeNode(variableNode, context) {
   const variableIdentifier = variableNode.getVariableIdentifier(),
         identifier = variableIdentifier;  ///
@@ -1039,6 +956,18 @@ export function stepFromStepOrSubproofNode(stepOrSubproofNode, context) {
   return step;
 }
 
+export function assumptionFromJudgementNode(judgementNode, context) {
+  let assumption = null;
+
+  const assumptionNode = judgementNode.getAssumptionNode();
+
+  if (assumptionNode !== null) {
+    assumption = assumptionFromAssumptionNode(assumptionNode, context);
+  }
+
+  return assumption;
+}
+
 export function statementFromCombinatorNode(combinatorNode, context) {
   let statement = null;
 
@@ -1087,18 +1016,6 @@ export function referenceFromAssumptionNode(assumptionNode, context) {
   return reference;
 }
 
-export function assumptionFromJudgementNode(judgementNode, context) {
-  let assumption = null;
-
-  const assumptionNode = judgementNode.getAssumptionNode();
-
-  if (assumptionNode !== null) {
-    assumption = assumptionFromAssumptionNode(assumptionNode, context);
-  }
-
-  return assumption;
-}
-
 export function statementFromHypothesisNode(hypothesisNode, context) {
   let statement = null;
 
@@ -1159,16 +1076,16 @@ export function termFromPropertyRelationNode(propertyRelationNode, context) {
   return term;
 }
 
-export function termFromTermSubstitutionNode(termSubstitutionNode, context) {
-  let term = null;
+export function subDerivationFromSubproofNode(subproofNode, context) {
+  let subDerviation = null;
 
-  const termNode = termSubstitutionNode.getTermNode();
+  const subDerivationNode = subproofNode.getSubDerivationNode();
 
-  if (termNode !== null) {
-    term = termFromTermNode(termNode, context);
+  if (subDerivationNode !== null) {
+    subDerviation = subDerivationFromSubDerivationNode(subDerivationNode, context);
   }
 
-  return term;
+  return subDerviation;
 }
 
 export function metavariableFromStatementNode(statementNode, context) {
@@ -1183,18 +1100,6 @@ export function metavariableFromStatementNode(statementNode, context) {
   return metavariable;
 }
 
-export function subDerivationFromSubproofNode(subproofNode, context) {
-  let subDerviation = null;
-
-  const subDerivationNode = subproofNode.getSubDerivationNode();
-
-  if (subDerivationNode !== null) {
-    subDerviation = subDerivationFromSubDerivationNode(subDerivationNode, context);
-  }
-
-  return subDerviation;
-}
-
 export function metavariableFromReferenceNode(referenceNode, context) {
   let metavariable = null;
 
@@ -1207,10 +1112,23 @@ export function metavariableFromReferenceNode(referenceNode, context) {
   return metavariable;
 }
 
+export function referenceFromMetavariableNode(metavariableNode, context) {
+  const metavariableString = context.nodeAsString(metavariableNode);
+
+  return literally((context) => {
+    const referenceString = metavariableString, ///
+          string = referenceString,  ///
+          referenceNode = instantiateReference(string, context),
+          reference = referenceFromReferenceNode(referenceNode, context);
+
+    return reference;
+  }, context);
+}
+
 export function frameFromDefinedAssertionNode(definedAssertionNode, context) {
   let frame = null;
 
-  const frameNode = definedAssertionNode.getTermNode();
+  const frameNode = definedAssertionNode.getFrameNode();
 
   if (frameNode !== null) {
     frame = frameFromFrameNode(frameNode, context);
@@ -1243,12 +1161,6 @@ export function satisfiesAssertionFromStepNode(stepNode, context) {
   return satisfiesAssertion;
 }
 
-export function parameterNameFromParameterNode(parameterNode, context) {
-  const parameterName = parameterNode.getParameterName();
-
-  return parameterName;
-}
-
 export function typeAssertionFromStatementNode(statementNode, context) {
   let typeAssertion = null;
 
@@ -1261,40 +1173,16 @@ export function typeAssertionFromStatementNode(statementNode, context) {
   return typeAssertion;
 }
 
-export function metavariableFromAssumptionNode(assumptionNode, context) {
-  let metavariable = null;
-
-  const metavariableNode = assumptionNode.getMetavariableNode();
-
-  if (metavariableNode !== null) {
-    metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-  }
-
-  return metavariable;
-}
-
-export function referenceFromProcedureCallNode(procedureCallNode, context) {
-  let reference = null;
-
-  const referenceNode = procedureCallNode.getReferenceNode();
-
-  if (referenceNode !== null) {
-    reference = referenceFromReferenceNode(referenceNode, context);
-  }
-
-  return reference;
-}
-
-export function frameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
-  let frame = null;
+export function proofFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
+  let proof = null;
 
-  const frameNode = frameSubstitutionNode.getFrameNode();
+  const proofNode = topLevelAsssertionNode.getProofNode();
 
-  if (frameNode !== null) {
-    frame = frameFromFrameNode(frameNode, context);
+  if (proofNode !== null) {
+    proof = proofFromProofNode(proofNode, context);
   }
 
-  return frame;
+  return proof;
 }
 
 export function subproofFromStepOrSubproofNode(subproofOrSubproofNode, context) {
@@ -1323,16 +1211,10 @@ export function termFromContainedAssertionNode(containedAssertionNode, context)
   return term;
 }
 
-export function typeFromPropertyDeclarationNode(propertyDeclarationNode, context) {
-  let type = null;
-
-  const typeNode = propertyDeclarationNode.getTypeNode();
-
-  if (typeNode !== null) {
-    type = typeFromTypeNode(typeNode, context);
-  }
+export function nameFromProcedureReferenceNode(procedureReferenceNode, context) {
+  const name = procedureReferenceNode.getName();
 
-  return type;
+  return name;
 }
 
 export function frameFromContainedAssertionNode(containedAssertionNode, context) {
@@ -1371,18 +1253,6 @@ export function propertyFromPropertyRelationNode(propertyRelationNode, context)
   return property;
 }
 
-export function variableFromTermSubstitutionNode(termSubstitutionNode, context) {
-  let variable = null;
-
-  const variableNode = termSubstitutionNode.getMetavariableNode();
-
-  if (variableNode !== null) {
-    variable = variableFromVariableNode(variableNode, context);
-  }
-
-  return variable;
-}
-
 export function definedAssertionFromStatementNode(statementNode, context) {
   let definedAssertion = null;
 
@@ -1407,7 +1277,55 @@ export function termSubstitutionFromStatementNode(statementNode, context) {
   return termSubstitution;
 }
 
-export function proofFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
+export function typeFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
+  let type = null;
+
+  const typeNode = simpleTypeDeclarationNode.getTypeNode();
+
+  if (typeNode !== null) {
+    type = typeFromTypeNode(typeNode, context);
+  }
+
+  return type;
+}
+
+export function targetTermFromTermSubstitutionNode(termSubstitutionNode, context) {
+  let targetTerm = null;
+
+  const targetTermNode = termSubstitutionNode.getTargetTermNode();
+
+  if (targetTermNode !== null) {
+    targetTerm = termFromTermNode(targetTermNode, context);
+  }
+
+  return targetTerm;
+}
+
+export function deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
+  let deduction = null;
+
+  const deductionNode = topLevelAsssertionNode.getDeductionNode();
+
+  if (deductionNode !== null) {
+    deduction = deductionFromDeductionNode(deductionNode, context);
+  }
+
+  return deduction;
+}
+
+export function signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
+  let signature = null;
+
+  const signatureNode = topLevelAsssertionNode.getSignatureNode();
+
+  if (signatureNode !== null) {
+    signature = signatureFromSignatureNode(signatureNode, context);
+  }
+
+  return signature;
+}
+
+export function proofFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
   let proof = null;
 
   const proofNode = metaLemmaMetathoremNode.getProofNode();
@@ -1419,7 +1337,7 @@ export function proofFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, conte
   return proof;
 }
 
-export function labelFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
+export function labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
   let label = null;
 
   const labelNode = metaLemmaMetathoremNode.getLabelNode();
@@ -1431,18 +1349,6 @@ export function labelFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, conte
   return label;
 }
 
-export function typeFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
-  let type = null;
-
-  const typeNode = simpleTypeDeclarationNode.getTypeNode();
-
-  if (typeNode !== null) {
-    type = typeFromTypeNode(typeNode, context);
-  }
-
-  return type;
-}
-
 export function frameSubstitutionFromStatementNode(statementNode, context) {
   let frameSubstitution = null;
 
@@ -1455,17 +1361,6 @@ export function frameSubstitutionFromStatementNode(statementNode, context) {
   return frameSubstitution;
 }
 
-export function stepsOrSubproofsFromDerivationNode(derivationNode, context) {
-  const stepOrSubproofNodes = derivationNode.getStepOrSubproofNodes(),
-        stepsOrSubproofs = stepOrSubproofNodes.map((stepOrSubproofNode) => {
-          const stepOrSubproof = stepsOrSubproofFromStepOrSubproofNode(stepOrSubproofNode, context);
-
-          return stepOrSubproof;
-        });
-
-  return stepsOrSubproofs;
-}
-
 export function propertyAssertionFromStatementNode(statementNode, context) {
   let propertyAssertion = null;
 
@@ -1490,16 +1385,15 @@ export function subproofAssertionFromStatementNode(statementNode, context) {
   return subproofAssertion;
 }
 
-export function termFromConstructorDeclarationNode(constructorDeclarationNode, context) {
-  let term = null;
-
-  const termNode = constructorDeclarationNode.getTermNode();
+export function stepsOrSubproofsFromDerivationNode(derivationNode, context) {
+  const stepOrSubproofNodes = derivationNode.getStepOrSubproofNodes(),
+        stepsOrSubproofs = stepOrSubproofNodes.map((stepOrSubproofNode) => {
+          const stepOrSubproof = stepsOrSubproofFromStepOrSubproofNode(stepOrSubproofNode, context);
 
-  if (termNode !== null) {
-    term = termFromTermNode(termNode, context);
-  }
+          return stepOrSubproof;
+        });
 
-  return term;
+  return stepsOrSubproofs;
 }
 
 export function typeFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
@@ -1514,22 +1408,6 @@ export function typeFromComplexTypeDeclarationNode(complexTypeDeclarationNode, c
   return type;
 }
 
-export function typeFromConstructorDeclarationNode(constructorDeclarationNode, context) {
-  let type;
-
-  const typeNode = constructorDeclarationNode.getTypeNode();
-
-  if (typeNode !== null) {
-    type = typeFromTypeNode(typeNode, context);
-  } else {
-    const baseType = baseTypeFromNothing();
-
-    type = baseType;  ///
-  }
-
-  return type;
-}
-
 export function containedAssertionFromStatementNode(statementNode, context) {0
   let containedAssertion = null;
 
@@ -1566,18 +1444,6 @@ export function statementFromContainedAssertionNode(containedAssertionNode, cont
   return statement;
 }
 
-export function propertyFromPropertyDeclarationNode(propertyDeclarationNode, context) {
-  let property = null;
-
-  const propertyNode = propertyDeclarationNode.getPropertyNode();
-
-  if (propertyNode !== null) {
-    property = propertyFromPropertyNode(propertyNode, context);
-  }
-
-  return property;
-}
-
 export function signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
   let signature = null;
 
@@ -1602,16 +1468,22 @@ export function referenceFromSatisfiesAssertionNode(satisfiesAssertionNode, cont
   return reference;
 }
 
-export function variableFromVariableDeclarationNode(variableDeclarationNode, context) {
-  let variable = null;
+export function hypothesesFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
+  const ypotheses = [];
+
+  return ypotheses;
+}
 
-  const variableNode = variableDeclarationNode.getVariableNode();
+export function targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
+  let targetFrame = null;
 
-  if (variableNode !== null) {
-    variable = variableFromVariableNode(variableNode, context);
+  const targetFrameNode = frameSubstitutionNode.getTargetFrameNode();
+
+  if (targetFrameNode !== null) {
+    targetFrame = frameFromFrameNode(targetFrameNode, context);
   }
 
-  return variable;
+  return targetFrame;
 }
 
 export function stepsOrSubproofsFromSubDerivationNode(subDerivationNode, context) {
@@ -1625,19 +1497,25 @@ export function stepsOrSubproofsFromSubDerivationNode(subDerivationNode, context
   return stepsOrSubproofs;
 }
 
-export function metavariableFromFrameSubstitutionNode(frameSubstitutionNode, context) {
-  let metavariable = null;
+export function prefixedFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
+  const prefixed = simpleTypeDeclarationNode.isPrefixed();
 
-  const metavariableNode = frameSubstitutionNode.getMetavariableNode();
+  return prefixed;
+}
 
-  if (metavariableNode !== null) {
-    metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-  }
+export function resolvedFromStatementSubstitutionNode(statementSubstitutionNode, substitution, context) {
+  const resolved = (substitution === null);
 
-  return metavariable;
+  return resolved;
 }
 
-export function deductionFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
+export function prefixedFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
+  const prefixed = complexTypeDeclarationNode.isPrefixed();
+
+  return prefixed;
+}
+
+export function deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
   let deduction = null;
 
   const deductionNode = metaLemmaMetathoremNode.getDeductionNode();
@@ -1649,42 +1527,6 @@ export function deductionFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, c
   return deduction;
 }
 
-export function statementFromStatementSubstitutionNode(statementSubstitutionNode, context) {
-  let statement = null;
-
-  const statementNode = statementSubstitutionNode.getStatementNode();
-
-  if (statementNode !== null) {
-    statement = statementFromStatementNode(statementNode, context);
-  }
-
-  return statement;
-}
-
-export function referenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
-  let reference = null;
-
-  const referenceNode = referenceSubstitutionNode.getReferenceNode();
-
-  if (referenceNode !== null) {
-    reference = referenceFromReferenceNode(referenceNode, context);
-  }
-
-  return reference;
-}
-
-export function statementFromCombinatorDeclarationNode(combinatorDeclarationNode, context) {
-  let statement = null;
-
-  const statementNode = combinatorDeclarationNode.getStatementNode();
-
-  if (statementNode !== null) {
-    statement = statementFromStatementNode(statementNode, context);
-  }
-
-  return statement;
-}
-
 export function procedureReferenceFromProcedureCallNode(procedureCallNode, context) {
   let procedureReference = null;
 
@@ -1697,6 +1539,18 @@ export function procedureReferenceFromProcedureCallNode(procedureCallNode, conte
   return procedureReference;
 }
 
+export function replacementTermFromTermSubstitutionNode(termSubstitutionNode, context) {
+  let replacementTerm = null;
+
+  const replacementTermNode = termSubstitutionNode.getReplacementTermNode();
+
+  if (replacementTermNode !== null) {
+    replacementTerm = termFromTermNode(replacementTermNode, context);
+  }
+
+  return replacementTerm;
+}
+
 export function typePrefixFromTypePrefixDeclarationNode(typePrefixDeclarationNode, context) {
   let typePrefix = null;
 
@@ -1733,16 +1587,16 @@ export function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationN
   return metaType;
 }
 
-export function proofFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
-  let proof = null;
+export function replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
+  let replacementFrame = null;
 
-  const proofNode = axiomLemmaTheoremConjectureNode.getProofNode();
+  const replacementFrameNode = frameSubstitutionNode.getReplacementFrameNode();
 
-  if (proofNode !== null) {
-    proof = proofFromProofNode(proofNode, context);
+  if (replacementFrameNode !== null) {
+    replacementFrame = frameFromFrameNode(replacementFrameNode, context);
   }
 
-  return proof;
+  return replacementFrame;
 }
 
 export function propertyRelationFromPropertyAssertionNode(propertyAssertionNode, context) {
@@ -1769,10 +1623,10 @@ export function constructorFromConstructorDeclarationNode(constructorDeclaration
   return constructor;
 }
 
-export function metavariableFromStatementSubstitutionNode(statementSubstitutionNode, context) {
+export function metavariableFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
   let metavariable = null;
 
-  const metavariableNode = statementSubstitutionNode.getMetavariableNode();
+  const metavariableNode = metavariableDeclarationNode.getMetavariableNode();
 
   if (metavariableNode !== null) {
     metavariable = metavariableFromMetavariableNode(metavariableNode, context);
@@ -1781,52 +1635,52 @@ export function metavariableFromStatementSubstitutionNode(statementSubstitutionN
   return metavariable;
 }
 
-export function metavariableFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
-  let metavariable = null;
+export function targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
+  let targetRefernece = null;
 
-  const metavariableNode = referenceSubstitutionNode.getMetavariableNode();
+  const targetReferenceNode = referenceSubstitutionNode.getTargetReferenceNode();
 
-  if (metavariableNode !== null) {
-    metavariable = metavariableFromMetavariableNode(metavariableNode, context);
+  if (targetReferenceNode !== null) {
+    targetRefernece = metavariableFromMetavariableNode(targetReferenceNode, context);
   }
 
-  return metavariable;
+  return targetRefernece;
 }
 
-export function metavariableFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
-  let metavariable = null;
+export function targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, context) {
+  let targetStatement = null;
 
-  const metavariableNode = metavariableDeclarationNode.getMetavariableNode();
+  const targetStatementNode = statementSubstitutionNode.getTargetStatementNode();
 
-  if (metavariableNode !== null) {
-    metavariable = metavariableFromMetavariableNode(metavariableNode, context);
+  if (targetStatementNode !== null) {
+    targetStatement = statementFromStatementNode(targetStatementNode, context);
   }
 
-  return metavariable;
+  return targetStatement;
 }
 
-export function deductionFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
-  let deduction = null;
+export function replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
+  let replacementReference = null;
 
-  const deductionNode = axiomLemmaTheoremConjectureNode.getDeductionNode();
+  const replacementReferenceNode = referenceSubstitutionNode.getReplacementReferenceNode();
 
-  if (deductionNode !== null) {
-    deduction = deductionFromDeductionNode(deductionNode, context);
+  if (replacementReferenceNode !== null) {
+    replacementReference = referenceFromReferenceNode(replacementReferenceNode, context);
   }
 
-  return deduction;
+  return replacementReference;
 }
 
-export function signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
-  let signature = null;
+export function replacementStatementFromStatementSubstitutionNode(statementSubstitutionNode, context) {
+  let replacementStatement = null;
 
-  const signatureNode = axiomLemmaTheoremConjectureNode.getSignatureNode();
+  const replacementStatementNode = statementSubstitutionNode.getReplacementStatementNode();
 
-  if (signatureNode !== null) {
-    signature = signatureFromSignatureNode(signatureNode, context);
+  if (replacementStatementNode !== null) {
+    replacementStatement = statementFromStatementNode(replacementStatementNode, context);
   }
 
-  return signature;
+  return replacementStatement;
 }
 
 export function termsFromTermNodes(termNodes, context) {
@@ -1869,26 +1723,6 @@ export function statementsFromStatementNodes(statementNodes, context) {
   return statements;
 }
 
-export function superTypesFromSuperTypeNodes(superTypeNodes, context) {
-  const superTypes = superTypeNodes.map((superTypeNode) => {
-          const typeNode = superTypeNode, ///
-                type = typeFromTypeNode(typeNode, context),
-                superType = type;  ///
-
-          return superType;
-        }),
-        superTypesLength = superTypes.length;
-
-  if (superTypesLength === 0) {
-    const baseType = baseTypeFromNothing(),
-          superType = baseType; ///
-
-    superTypes.push(superType);
-  }
-
-  return superTypes;
-}
-
 export function parametersFromParameterNodes(parameterNodes, context) {
   const parameters = parameterNodes.map((parameterNode) => {
     const parameter = parameterFromParameterNode(parameterNode, context);
@@ -1929,16 +1763,6 @@ export function suppositionsFromSuppositionNodes(suppositionNodes, context) {
   return suppositions;
 }
 
-export function propertiesFromPropertyDeclarationNodes(propertyDeclarationNodes, context) {
-  const properties = propertyDeclarationNodes.map((propertyDeclarationNode) => {
-    const property = propertyFromPropertyDeclarationNode(propertyDeclarationNode, context);
-
-    return property;
-  });
-
-  return properties;
-}
-
 export function labelsFromRuleNode(ruleNode, context) {
   const labelNodes = ruleNode.getLabelNodes(),
         labels = labelsFromLabelNodes(labelNodes, context);
@@ -1988,6 +1812,13 @@ export function parametersFromProcedureCallNode(procedureCallNode, context) {
   return parameters;
 }
 
+export function labelsFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
+  const labelNodes = topLevelAsssertionNode.getLabelNodes(),
+        labels = labelsFromLabelNodes(labelNodes, context);
+
+  return labels;
+}
+
 export function statementsFromSubproofAssertionNode(subproofAssertionNode, context) {
   const statementNodes = subproofAssertionNode.getStatementNodes(),
         statements = statementsFromStatementNodes(statementNodes, context);
@@ -1995,54 +1826,16 @@ export function statementsFromSubproofAssertionNode(subproofAssertionNode, conte
   return statements;
 }
 
-export function suppositionsFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
-  const suppositionNodes = metaLemmaMetathoremNode.getSuppositionNodes(),
+export function suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
+  const suppositionNodes = topLevelAsssertionNode.getSuppositionNodes(),
         suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);
 
   return suppositions;
 }
 
-export function propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
-  const propertyDeclarationNodes = complexTypeDeclarationNode.getPropertyDeclarationNodes(),
-        properties = propertiesFromPropertyDeclarationNodes(propertyDeclarationNodes, context);
-
-  return properties;
-}
-
-export function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
-  const superTypeNodes = complexTypeDeclarationNode.getSuperTypeNodes(),
-        superTypes = superTypesFromSuperTypeNodes(superTypeNodes, context);
-
-  return superTypes;
-}
-
-export function labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
-  const labelNodes = axiomLemmaTheoremConjectureNode.getLabelNodes(),
-        labels = labelsFromLabelNodes(labelNodes, context);
-
-  return labels;
-}
-
-export function suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
-  const suppositionNodes = axiomLemmaTheoremConjectureNode.getSuppositionNodes(),
+export function suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
+  const suppositionNodes = metaLemmaMetathoremNode.getSuppositionNodes(),
         suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);
 
   return suppositions;
 }
-
-
-
-
-export function _typeFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
-  let type = null;
-
-  const typeNode = metavariableDeclarationNode.getTypeNode();
-
-  if (typeNode !== null) {
-    const nominalTypeName = typeNode.getNominalTypeName();
-
-    type = context.findTypeByNominalTypeName(nominalTypeName);
-  }
-
-  return type;
-}