occam-verify-cli 1.0.427 → 1.0.436

package/src/utilities/element.js

@@ -3,8 +3,14 @@
 import elements from "../elements";
 
 import { baseType } from "../element/type";
-import { subproofStringFromSubproofNode, stringFromLabelsSuppositionsAndDeduction } from "../utilities/string";
-import node from "occam-parsers/lib/mixins/node";
+import { instantiateReference } from "../process/instantiate";
+import { equivalenceStringFromTerms,
+         subproofStringFromSubproofNode,
+         rulsStringFromLabelsPremisesAndConclusion,
+         procedureCallStringFromProcedureReferenceAndParameters,
+         sectionStringFromHypothesesAxiomLemmaTheoremAndConjecture,
+         metaLemmaMetatheoremStringFromLabelSuppositionsAndDeduction,
+         axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction } from "../utilities/string";
 
 export function typeFromTypeNode(typeNode, context) {
   let type;
@@ -24,7 +30,7 @@ export function typeFromTypeNode(typeNode, context) {
           properties = null,
           provisional = null;
 
-    type = new Type(string, node, name, prefixName, superTypes, properties, provisional);
+    type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
   }
 
   return type;
@@ -35,7 +41,7 @@ export function termFromTermNode(termNode, context) {
         node = termNode,  ///
         string = context.nodeAsString(node),
         type = null,
-        term = new Term(string, node, type);
+        term = new Term(context, string, node, type);
 
   return term;
 }
@@ -52,7 +58,40 @@ export function stepFromStepNode(stepNode, context) {
   return step;
 }
 
-export function lemmaromAxiomNode(lemmaNode, context) {
+export function ruleFromRuleNode(ruleNode, context) {
+  const { Rule } = elements,
+        proof = proofFromRuleNode(ruleNode, context),
+        labels = labelsFromRuleNode(ruleNode, context),
+        premises = premisesFromRuleNode(ruleNode, context),
+        conclusion = conclusionFromRuleNode(ruleNode, context),
+        ruleString = rulsStringFromLabelsPremisesAndConclusion(labels, premises, conclusion),
+        node = ruleNode,  ///
+        string = ruleString,  ///
+        rule = new Rule(context, string, node, labels, premises, conclusion, proof);
+
+  return rule;
+}
+
+export function labelFromLabelNode(labelNode, context) {
+  const { Label } = elements,
+        node = labelNode, ///
+        string = context.nodeAsString(node),
+        metavariable = metavariableFromLabelNode(labelNode, context),
+        label = new Label(context, string, node, metavariable);
+
+  return label;
+}
+
+export function errorFromErrorNode(errorNode, context) {
+  const { Error } = elements,
+        node = errorNode, ///
+        string = context.nodeAsString(node),
+        error = new Error(context, string, node);
+
+  return error;
+}
+
+export function lemmaFromLemmaNode(lemmaNode, context) {
   const { Lemma } = elements,
         axiomLemmaTheoremConjectureNode = lemmaNode,  ///
         proof = proofFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
@@ -61,8 +100,9 @@ export function lemmaromAxiomNode(lemmaNode, context) {
         suppositions = suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
         signature = signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
         hypotheses = [],
+        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = lemmaNode, ///
-        string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        string = axiomLemmaTheoremConjectureString, ///
         lemma = new Lemma(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
   return lemma;
@@ -73,7 +113,7 @@ export function frameFromFrameNode(frameNode, context) {
     node = frameNode, ///
     string = context.nodeAsString(node),
     assumptions = assumptionsFromFrameNode(frameNode, context),
-    frame = new Frame(string, node, assumptions);
+    frame = new Frame(context, string, node, assumptions);
 
   return frame;
 }
@@ -83,7 +123,7 @@ export function proofFromProofNode(proofNode, context) {
         node = proofNode, ///
         string = null,
         derivation = derivationFromProofNode(proofNode, context),
-        proof = new Proof(string, node, derivation);
+        proof = new Proof(context, string, node, derivation);
 
   return proof;
 }
@@ -97,14 +137,41 @@ export function axiomFromAxiomNode(axiomNode, context) {
         suppositions = suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
         signature = signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
         hypotheses = [],
+        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = axiomNode, ///
-        string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        string = axiomLemmaTheoremConjectureString, ///
         axiom = new Axiom(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
   return axiom;
 }
 
-export function theoremromAxiomNode(theoremNode, context) {
+export function sectionFromSectionNode(sectionNode, context) {
+  const hypothesisNodes = sectionNode.getHypothesisNodes(),
+        hypotheses = hypothesesFromHypothesisNodes(hypothesisNodes, context),
+        axiom = axiomFromSectionNode(sectionNode, context),
+        lemma = lemmaFromSectionNode(sectionNode, context),
+        theorem = theoremFromSectionNode(sectionNode, context),
+        conjecture = conjectureFromSectionNode(sectionNode, context),
+        sectionString = sectionStringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context),
+        node = sectionNode, ///
+        string = sectionString, ///
+        section = new Section(context, string, node, hypotheses, axiom, lemma, theorem, conjecture);
+
+  return section;
+}
+
+export function premiseFromPremiseNode(premiseNode, context) {
+  const { Premise } = elements,
+        node = premiseNode, ///
+        string = context.nodeAsString(node),
+        statement = statementFromPremiseNode(premiseNode, context),
+        procedureCall = procedureCallFromPremiseNode(premiseNode, context),
+        premise = new Premise(context, string, node, statement, procedureCall);
+
+  return premise
+}
+
+export function theoremFromTheoremNode(theoremNode, context) {
   const { Theorem } = elements,
         axiomLemmaTheoremConjectureNode = theoremNode,  ///
         proof = proofFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
@@ -113,29 +180,14 @@ export function theoremromAxiomNode(theoremNode, context) {
         suppositions = suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
         signature = signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
         hypotheses = [],
+        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = theoremNode, ///
-        string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        string = axiomLemmaTheoremConjectureString, ///
         theorem = new Theorem(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
   return theorem;
 }
 
-export function conjectureromAxiomNode(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),
-        hypotheses = [],
-        node = conjectureNode, ///
-        string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
-        conjecture = new Conjecture(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
-
-  return conjecture;
-}
-
 export function equalityFromEqualityNode(equalityNode, context) {
   const { Equality } = elements,
         node = equalityNode,  ///
@@ -155,19 +207,19 @@ export function metaTypeFromMetaTypeNode(metaTypeNode, context) {
         string = context.nodeAsString(node),
         metaTypeName = metaTypeNode.getMetaTypeName(),
         name = metaTypeName,  ///
-        metaType = new MetaType(string, node, name);
+        metaType = new MetaType(context, string, node, name);
 
   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(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;
 }
@@ -179,7 +231,7 @@ export function variableFromVariableNode(variableNode, context) {
         type = null,
         identifier = identifierFromVarialbeNode(variableNode, context),
         propertyRelations = [],
-        variable = new Variable(string, node, type, identifier, propertyRelations);
+        variable = new Variable(context, string, node, type, identifier, propertyRelations);
 
   return variable;
 }
@@ -191,7 +243,7 @@ export function subproofFromSubproofNode(subproofNode, context) {
         subDerivation = subDerivationFromSubproofNode(subproofNode, context),
         subproofString = subproofStringFromSubproofNode(subproofNode, context),
         string = subproofString,  ///
-        subproof = new SubProof(string, node, suppositions, subDerivation);
+        subproof = new SubProof(context, string, node, suppositions, subDerivation);
 
   return subproof;
 }
@@ -227,7 +279,7 @@ export function statementFromStatementNode(statementNode, context) {
   const { Statement } = elements,
         node = statementNode, ///
         string = context.nodeAsString(node),
-        statement = new Statement(string, node);
+        statement = new Statement(context, string, node);
 
   return statement;
 }
@@ -237,7 +289,7 @@ export function signatureFromSignatureNode(signatureNode, context) {
         node = signatureNode, ///
         string = context.nodeAsString(node),
         terms = termsFromSignatureNode(signatureNode, context),
-        signature = new Signature(string, node, terms);
+        signature = new Signature(context, string, node, terms);
 
   return signature;
 }
@@ -247,17 +299,91 @@ export function referenceFromReferenceNode(referenceNode, context) {
         node = referenceNode, ///
         string = context.nodeAsString(node),
         metavariable = metavariableFromReferenceNode(referenceNode, context),
-        reference = new Reference(string, node, metavariable);
+        reference = new Reference(context, string, node, metavariable);
 
   return reference;
 }
 
+export function conjectureroConjectureNode(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),
+        hypotheses = [],
+        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        node = conjectureNode, ///
+        string = axiomLemmaTheoremConjectureString, ///
+        conjecture = new Conjecture(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
+
+  return conjecture;
+}
+
+export function judgementFromJudgementNode(judgementNode, context) {
+  const { Judgement } = elements,
+        node = judgementNode, ///
+        string = context.nodeAsString(node),
+        frame = frameFromJudgementNode(judgementNode, context),
+        assumption = assumptionFromJudgementNode(judgementNode, context),
+        judgement = new Judgement(context, string, node, frame, assumption);
+
+  return judgement;
+}
+
+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),
+        substitutions = null,
+        node = metaLemmaNode, ///
+        string = metaLemmaMetatheoremStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
+        metaLemma = new MetaLemma(context, string, node, label, suppositions, deduction, proof, substitutions);
+
+  return metaLemma;
+}
+
+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);
+
+  return parameter;
+}
+
+export function hypothesisFromHypothesisNode(hypotheseNode, context) {
+  const { Hypothsis } = elements,
+        node = hypotheseNode, ///
+        string = context.nodeAsString(node),
+        statement = statementFromHypothesisNode(hypotheseNode, context),
+        parameter = new Hypothsis(context, string, node, statement);
+
+  return parameter;
+}
+
+export function conclusionFromConclusionNode(conclusionNode, context) {
+  const { Conclusion } = elements,
+        node = conclusionNode, ///
+        string = context.nodeAsString(node),
+        statement = statementFromConclusionNode(conclusionNode, context),
+        conclusion = new Conclusion(context, string, node, statement);
+
+  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);
+        node = conclusinoNode, ///
+        string = context.nodeAsString(node),
+        statement = statementFromConclusionNode(conclusinoNode, context),
+        conclusino = new Conclusion(context, string, node, statement);
 
   return conclusino;
 }
@@ -268,7 +394,7 @@ export function assumptionFromAssumptionNode(assumptionNode, context) {
         string = context.nodeAsString(node),
         statement = statementFromAssumptionNode(assumptionNode, context),
         reference = referenceFromAssumptionNode(assumptionNode, context),
-        assumption = new Assumption(string, node, statement, reference);
+        assumption = new Assumption(context, string, node, statement, reference);
 
   return assumption;
 }
@@ -278,7 +404,7 @@ export function derivationFromDerivationNode(derivationNode, context) {
         node = derivationNode,  ///
         string = null,
         stepsOrSubproofs = stepsOrSubproofsFromDerivationNode(derivationNode, context),
-        derivation = new Derivation(string, node, stepsOrSubproofs);
+        derivation = new Derivation(context, string, node, stepsOrSubproofs);
 
   return derivation;
 }
@@ -289,11 +415,74 @@ export function typePrefixFromTypePrefixNode(typePrefixNode, context) {
         string = context.nodeAsString(node),
         term = termFromTypePrefixNode(typePrefixNode, context),
         type = typeFromTypePrefixNode(typePrefixNode, context),
-        typePrefix = new TypePrefix(string, node, term, type);
+        typePrefix = new TypePrefix(context, string, node, term, type);
 
   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 suppositionFromSuppositionNode(suppositionNode, context) {
+  const { Supposition } = elements,
+        node = suppositionNode, ///
+        string = context.nodeAsString(node),
+        statement = statementFromSuppositionNode(suppositionNode, context),
+        procedureCall = procedureCallFromSuppositionNode(suppositionNode, context),
+        supposition = new Supposition(context, string, node, statement, procedureCall);
+
+  return supposition
+}
+
+export function equivalenceFromEquivalenceNode(equivalenceNode, context) {
+  const { Equivalence } = elements,
+        node = equivalenceNode, ///
+        terms = termsFromEquivalenceNode(equivalenceNode, context),
+        equivalenceString = equivalenceStringFromTerms(terms),
+        string = equivalenceString, ///
+        equivalence = new Equivalence(context, string, node, terms);
+
+  return equivalence;
+}
+
+export function nameFromProcedureReferenceNode(procedureReferenceNode, context) {
+  const name = procedureReferenceNode.getName();
+
+  return name;
+}
+
 export function metavariableFromMetavariableNode(metavariableNode, context) {
   const { Metavariable } = elements,
         node = metavariableNode,  ///
@@ -302,7 +491,7 @@ export function metavariableFromMetavariableNode(metavariableNode, context) {
         name = metavariableName,  ///
         type = null,
         metaType = null,
-        metavariable = new Metavariable(string, node, name, type, metaType);
+        metavariable = new Metavariable(context, string, node, name, type, metaType);
 
   return metavariable;
 }
@@ -312,7 +501,7 @@ export function subDerivationFromSubDerivationNode(subDerivationNode, context) {
         node = subDerivationNode, ///
         string = null,
         stepsOrSubproofs = stepsOrSubproofsFromSubDerivationNode(subDerivationNode, context),
-        subDerivation = new SubDerivation(string, node, stepsOrSubproofs);
+        subDerivation = new SubDerivation(context, string, node, stepsOrSubproofs);
 
   return subDerivation;
 
@@ -324,11 +513,23 @@ export function typeAssertionFromTypeAssertionNode(typeAssertionNode, context) {
         string = context.nodeAsString(node),
         term = termFromTypeAssertionNode(typeAssertionNode, context),
         type = typeFromTypeAssertionNode(typeAssertionNode, context),
-        typeAssertion = new TypeAssertion(string, node, term, type);
+        typeAssertion = new TypeAssertion(context, string, node, term, type);
 
   return typeAssertion;
 }
 
+export function procedureCallFromProcedureCallNode(procedureCallNode, context) {
+  const { ProcedureCall } = elements,
+        parameters = parametersFromProcedureCallNode(procedureCallNode, context),
+        procedureReference = procedureReferenceFromProcedureCallNode(procedureCallNode, context),
+        procedureCallString = procedureCallStringFromProcedureReferenceAndParameters(procedureReference, parameters),
+        node = procedureCallNode, ///
+        string = procedureCallString, ///
+        procedureCall = new ProcedureCall(context, string, node, parameters, procedureReference);
+
+  return procedureCall;
+}
+
 export function stepsOrSubproofFromStepOrSubproofNode(stepOrSubproofNode, context) {
   const step = stepFromStepOrSubproofNode(stepOrSubproofNode, context),
         subproof = subproofFromStepOrSubproofNode(stepOrSubproofNode, context),
@@ -356,7 +557,7 @@ export function definedAssertionFromDefinedAssertionNode(definedAssertionNode, c
         negated = definedAssertionNode.isNegated(),
         term = termFromDefinedAssertionNode(definedAssertionNode, context),
         frame = frameFromDefinedAssertionNode(definedAssertionNode, context),
-        definedAssertion = new DefinedAssertion(string, node, term, frame, negated);
+        definedAssertion = new DefinedAssertion(context, string, node, term, frame, negated);
 
   return definedAssertion;
 }
@@ -367,7 +568,7 @@ export function propertyRelationFromPropertyRelationNode(propertyRelationNode, c
         string = context.nodeAsString(node),
         property = propertyFromPropertyRelationNode(propertyRelationNode, context),
         term = termFromPropertyRelationNode(propertyRelationNode, context),
-        propertyRelation = new PropertyRelation(string, node, property, term);
+        propertyRelation = new PropertyRelation(context, string, node, property, term);
 
   return propertyRelation;
 }
@@ -400,7 +601,7 @@ export function propertyAssertionFromPropertyAssertionNode(propertyAssertionNode
         string = context.nodeAsString(node),
         term = termFromPropertyAssertionNode(propertyAssertionNode, context),
         propertyRelation = propertyRelationFromPropertyAssertionNode(propertyAssertionNode, context),
-        propertyAssertion = new PropertyAssertion(string, node, term, propertyRelation);
+        propertyAssertion = new PropertyAssertion(context, string, node, term, propertyRelation);
 
   return propertyAssertion;
 }
@@ -410,7 +611,7 @@ export function subproofAssertionFromSubproofAssertionNode(subproofAssertionNode
         node = subproofAssertionNode, ///
         string = context.nodeAsString(node),
         statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context),
-        subproofAssertion = new SubproofAssertion(string, node, statements);
+        subproofAssertion = new SubproofAssertion(context, string, node, statements);
 
   return subproofAssertion;
 }
@@ -423,7 +624,7 @@ export function containedAssertionFromContainedAssertionNode(containedAssertionN
         term = termFromContainedAssertionNode(containedAssertionNode, context),
         frame = frameFromContainedAssertionNode(containedAssertionNode, context),
         statement = statementFromContainedAssertionNode(containedAssertionNode, context),
-        containedAssertion = new ContainedAssertion(string, node, term, frame, negated, statement);
+        containedAssertion = new ContainedAssertion(context, string, node, term, frame, negated, statement);
 
   return containedAssertion;
 }
@@ -434,17 +635,27 @@ export function satisfiesAssertionFromSatisfiesAssertionNode(satisfiesAssertionN
         string = context.nodeAsString(node),
         signature = signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, context),
         reference = referenceFromSatisfiesAssertionNode(satisfiesAssertionNode, context),
-        satisfiesAssertion = new SatisfiesAssertion(string, node, signature, reference);
+        satisfiesAssertion = new SatisfiesAssertion(context, string, node, signature, reference);
 
   return satisfiesAssertion;
 }
 
+export function procedureReferenceFromProcedureReferenceNode(procedureReferenceNode, context) {
+  const { ProcedureReference } = elements,
+        node = procedureReferenceNode,  ///
+        string = context.nodeAsString(node),
+        name = nameFromProcedureReferenceNode(procedureReferenceNode, context),
+        variableDeclaration = new ProcedureReference(context, string, node, name);
+
+  return variableDeclaration;
+}
+
 export function variableDeclarationFromVariableDeclarationNode(variableDeclarationNode, context) {
   const { VariableDeclaration } = elements,
         node = variableDeclarationNode,  ///
         string = context.nodeAsString(node),
-        varialbe = variableFromVariableNode(variableDeclarationNode, context),
-        variableDeclaration = new VariableDeclaration(context, string, node, varialbe);
+        variable = variableFromVariableNode(variableDeclarationNode, context),
+        variableDeclaration = new VariableDeclaration(context, string, node, variable);
 
   return variableDeclaration;
 }
@@ -480,19 +691,14 @@ export function simpleTypeDeclarationFromSimpleTypeDeclarationNode(simpleTypeDec
   return simpleTypeDeclaration;
 }
 
-export function statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, substitution, context) {
-  if (context === undefined) {
-    context = substitution; ///
-
-    substitution = null;
-  }
-
+export function statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context) {
   const { StatementSubstitution } = elements,
         node = statementSubstitutionNode,  ///
         string = context.nodeAsString(node),
         resolved = true,
         statement = statementFromStatementSubstitutionNode(statementSubstitutionNode, context),
         metavariable = metavariableFromStatementSubstitutionNode(statementSubstitutionNode, context),
+        substitution = null,
         statementSubstitution = new StatementSubstitution(context, string, node, resolved, statement, metavariable, substitution);
 
   return statementSubstitution;
@@ -534,12 +740,64 @@ export function metavariableDeclarationFromMetavariableDeclarationNode(metavaria
   const { MetavariableDeclaration } = elements,
         node = metavariableDeclarationNode,  ///
         string = context.nodeAsString(node),
-        metavarialbe = metavariableFromMetavariableNode(metavariableDeclarationNode, context),
-        metavariableDeclaration = new MetavariableDeclaration(context, string, node, metavarialbe);
+        metaType = metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, context),
+        metavariable = metavariableFromMetavariableDeclarationNode(metavariableDeclarationNode, context);
+
+  metavariable.setMetaType(metaType);
+
+  const metavariableDeclaration = new MetavariableDeclaration(context, string, node, metavariable);
 
   return metavariableDeclaration;
 }
 
+export function proofFromRuleNode(ruleNode, context) {
+  let proof = null;
+
+  const proofNode = ruleNode.getProofNode();
+
+  if (proofNode !== null) {
+    proof = proofFromProofNode(proofNode, context);
+  }
+
+  return proof;
+}
+
+export function axiomFromSectionNode(sectionNode, context) {
+  let axiom = null;
+
+  const axiomNode = sectionNode.getAxiomNode();
+
+  if (axiomNode !== null) {
+    axiom = axiomFromAxiomNode(axiomNode, context);
+  }
+
+  return axiom;
+}
+
+export function lemmaFromSectionNode(sectionNode, context) {
+  let lemma = null;
+
+  const lemmaNode = sectionNode.getLemmaNode();
+
+  if (lemmaNode !== null) {
+    lemma = lemmaFromLemmaNode(lemmaNode, 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;
 
@@ -564,6 +822,42 @@ export function referenceFromStepNode(stepNode, context) {
   return reference;
 }
 
+export function conclusionFromRuleNode(ruleNode, context) {
+  let conclusion = null;
+
+  const conclusionNode = ruleNode.getConclusionNode();
+
+  if (conclusionNode !== null) {
+    conclusion = conclusionFromConclusionNode(conclusionNode, context);
+  }
+
+  return conclusion;
+}
+
+export function theoremFromSectionNode(sectionNode, context) {
+  let theorem = null;
+
+  const theoremNode = sectionNode.getTheoremNode();
+
+  if (theoremNode !== null) {
+    theorem = theoremFromTheoremNode(theoremNode, context);
+  }
+
+  return theorem;
+}
+
+export function frameFromJudgementNode(judgementNode, context) {
+  let frame = null;
+
+  const frameNode = judgementNode.getFrameNode();
+
+  if (frameNode !== null) {
+    frame = frameFromFrameNode(frameNode, context);
+  }
+
+  return frame;
+}
+
 export function derivationFromProofNode(proofNode, context) {
   let derivation = null;
 
@@ -576,6 +870,66 @@ export function derivationFromProofNode(proofNode, context) {
   return derivation;
 }
 
+export function statementFromPremiseNode(premiseNode, context) {
+  let statement = null;
+
+  const statementNode = premiseNode.getStatementNode();
+
+  if (statementNode !== null) {
+    statement = statementFromStatementNode(statementNode, context);
+  }
+
+  return statement;
+}
+
+export function metavariableFromLabelNode(labelNode, context) {
+  let metavariable = null;
+
+  const metavariableNode = labelNode.getMetavariableNode();
+
+  if (metavariableNode !== null) {
+    metavariable = metavariableFromMetavariableNode(metavariableNode, context);
+  }
+
+  return metavariable;
+}
+
+export function conjectureFromSectionNode(sectionNode, context) {
+  let conjecture = null;
+
+  const conjectureNode = sectionNode.getConjectureNode();
+
+  if (conjectureNode !== null) {
+    conjecture = conjectureFromConjectureNode(conjectureNode, 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 judgementFomStatementNode(statementNode, context) {
+  let judgement = null;
+
+  const judgementNode = statementNode.getJudgementNode();
+
+  if (judgementNode !== null) {
+    judgement = judgementFromJudgementNode(judgementNode, context);
+  }
+
+  return judgement;
+}
+
 export function termFromTypeAssertionNode(typeAssertionNode, context) {
   let term = null;
 
@@ -600,18 +954,16 @@ export function typeFromTypeAssertionNode(typeAssertionNode, context) {
   return type;
 }
 
-export function stepFromStepOrSubproofNode(stepOrSubproofNode, context) {
-  let step = null;
-
-  const stepOrSubproofNodeStepNode = stepOrSubproofNode.isStepNode();
+export function metavariableFromFrameNode(frameNode, context) {
+  let metavariable = null;
 
-  if (stepOrSubproofNodeStepNode) {
-    const stepNode = stepOrSubproofNode;  ///
+  const metavariableNode = frameNode.getMetavariableNode();
 
-    step = stepFromStepNode(stepNode, context);
+  if (metavariableNode !== null) {
+    metavariable = metavariableFromMetavariableNode(metavariableNode, context);
   }
 
-  return step;
+  return metavariable;
 }
 
 export function identifierFromVarialbeNode(variableNode, context) {
@@ -633,6 +985,20 @@ export function statementFromDeductionNode(deductionNode, context) {
   return statement;
 }
 
+export function stepFromStepOrSubproofNode(stepOrSubproofNode, context) {
+  let step = null;
+
+  const stepOrSubproofNodeStepNode = stepOrSubproofNode.isStepNode();
+
+  if (stepOrSubproofNodeStepNode) {
+    const stepNode = stepOrSubproofNode;  ///
+
+    step = stepFromStepNode(stepNode, context);
+  }
+
+  return step;
+}
+
 export function statementFromConclusionNode(conclusinoNode, context) {
   let statement = null;
 
@@ -660,10 +1026,10 @@ export function statementFromAssumptionNode(assumptionNode, context) {
 export function referenceFromAssumptionNode(assumptionNode, context) {
   let reference = null;
 
-  const referenceNode = assumptionNode.getReferenceNode();
+  const metavariableNode = assumptionNode.getMetavariableNode();
 
-  if (referenceNode !== null) {
-    reference = referenceFromReferenceNode(referenceNode, context);
+  if (metavariableNode !== null) {
+    reference = referenceFromMetavariableNode(metavariableNode, context);
   }
 
   return reference;
@@ -681,6 +1047,42 @@ export function assumptionFromJudgementNode(judgementNode, context) {
   return assumption;
 }
 
+export function statementFromHypothesisNode(hypothesisNode, context) {
+  let statement = null;
+
+  const statementNode = hypothesisNode.getStatementNode();
+
+  if (statementNode !== null) {
+    statement = statementFromStatementNode(statementNode, context);
+  }
+
+  return statement;
+}
+
+export function procedureCallFromPremiseNode(premiseNode, context) {
+  let procedureCall = null;
+
+  const procedureCallNode = premiseNode.getProcedureCallNode();
+
+  if (procedureCallNode !== null) {
+    procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
+  }
+
+  return procedureCall;
+}
+
+export function statementFromSuppositionNode(suppositionNode, context) {
+  let statement = null;
+
+  const statementNode = suppositionNode.getStatementNode();
+
+  if (statementNode !== null) {
+    statement = statementFromStatementNode(statementNode, context);
+  }
+
+  return statement; ///
+}
+
 export function termFromDefinedAssertionNode(definedAssertionNode, context) {
   let term = null;
 
@@ -717,8 +1119,22 @@ export function termFromTermSubstitutionNode(termSubstitutionNode, context) {
   return term;
 }
 
-export function subDerivationFromSubproofNode(subproofNode, context) {
-  let subDerviation = null;
+export function metavariableFromStatementNode(statementNode, context) {
+  let metavariable = null;
+
+  const singularMetavariableNode = statementNode.getSingularMetavariableNode();
+
+  if (singularMetavariableNode !== null) {
+    const metavariableNode = singularMetavariableNode;  ///
+
+    metavariable = metavariableFromMetavariableNode(metavariableNode, context);
+  }
+
+  return metavariable;
+}
+
+export function subDerivationFromSubproofNode(subproofNode, context) {
+  let subDerviation = null;
 
   const subDerivationNode = subproofNode.getSubDerivationNode();
 
@@ -744,10 +1160,10 @@ export function typeAssertinFromStatementNode(statementNode, context) {
 export function metavariableFromReferenceNode(referenceNode, context) {
   let metavariable = null;
 
-  const metavariableNode = referenceNode.getTermNode();
+  const metavariableNode = referenceNode.getMetavariableNode();
 
   if (metavariableNode !== null) {
-    metavariable = metavariableFromMetavaraibleNode(metavariableNode, context);
+    metavariable = metavariableFromMetavariableNode(metavariableNode, context);
   }
 
   return metavariable;
@@ -777,18 +1193,6 @@ export function termFromPropertyAssertionNode(propertyAssertionNode, context) {
   return term;
 }
 
-export function frameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
-  let frame = null;
-
-  const frameNode = frameSubstitutionNode.getFrameNode();
-
-  if (frameNode !== null) {
-    frame = frameFromFrameNode(frameNode, context);
-  }
-
-  return frame;
-}
-
 export function satisfiesAssertionFromStepNode(stepNode, context) {
   let satisfiesAssertion = null;
 
@@ -801,6 +1205,48 @@ export function satisfiesAssertionFromStepNode(stepNode, context) {
   return satisfiesAssertion;
 }
 
+export function parameterNameFromParameterNode(parameterNode, context) {
+  const parameterName = parameterNode.getParameterName();
+
+  return parameterName;
+}
+
+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;
+
+  const frameNode = frameSubstitutionNode.getFrameNode();
+
+  if (frameNode !== null) {
+    frame = frameFromFrameNode(frameNode, context);
+  }
+
+  return frame;
+}
+
 export function subproofFromStepOrSubproofNode(subproofOrSubproofNode, context) {
   let subproof = null;
 
@@ -827,6 +1273,18 @@ 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);
+  }
+
+  return type;
+}
+
 export function frameFromContainedAssertionNode(containedAssertionNode, context) {
   let frame = null;
 
@@ -863,28 +1321,28 @@ export function variableFromTermSubstitutionNode(termSubstitutionNode, context)
   return variable;
 }
 
-export function definedAssertionFromStatementNode(statementNode, context) {
-  let definedAssertion = null;
+export function procedureCallFromSuppositionNode(suppositionNode, context) {
+  let procedureCall = null;
 
-  const definedAssertionNode = statementNode.getDefinedAssertionNode();
+  const procedureCallNode = suppositionNode.getProcedureCallNode();
 
-  if (definedAssertionNode !== null) {
-    definedAssertion = definedAssertionFromDefinedAssertionNode(definedAssertionNode, context);
+  if (procedureCallNode !== null) {
+    procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
   }
 
-  return definedAssertion;
+  return procedureCall;
 }
 
-export function typeFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
-  let type = null;
+export function definedAssertionFromStatementNode(statementNode, context) {
+  let definedAssertion = null;
 
-  const typeNode = simpleTypeDeclarationNode.getTypeNode();
+  const definedAssertionNode = statementNode.getDefinedAssertionNode();
 
-  if (typeNode !== null) {
-    type = typeFromTypeNode(typeNode, context);
+  if (definedAssertionNode !== null) {
+    definedAssertion = definedAssertionFromDefinedAssertionNode(definedAssertionNode, context);
   }
 
-  return type;
+  return definedAssertion;
 }
 
 export function termSubstitutionFromStatementNode(statementNode, context) {
@@ -899,6 +1357,42 @@ export function termSubstitutionFromStatementNode(statementNode, context) {
   return termSubstitution;
 }
 
+export function proofFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
+  let proof = null;
+
+  const proofNode = metaLemmaMetathoremNode.getProofNode();
+
+  if (proofNode !== null) {
+    proof = proofFromProofNode(proofNode, context);
+  }
+
+  return proof;
+}
+
+export function labelFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
+  let label = null;
+
+  const labelNode = metaLemmaMetathoremNode.getLabelNode();
+
+  if (labelNode !== null) {
+    label = labelFromLabelNode(labelNode, context);
+  }
+
+  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;
 
@@ -946,6 +1440,18 @@ export function subproofAssertionFromStatementNode(statementNode, context) {
   return subproofAssertion;
 }
 
+export function termFromConstructorDeclarationNode(constructorDeclarationNode, context) {
+  let term = null;
+
+  const termNode = constructorDeclarationNode.getTermNode();
+
+  if (termNode !== null) {
+    term = termFromTermNode(termNode, context);
+  }
+
+  return term;
+}
+
 export function typeFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
   let type = null;
 
@@ -958,28 +1464,30 @@ export function typeFromComplexTypeDeclarationNode(complexTypeDeclarationNode, c
   return type;
 }
 
-export function containedAssertionFromStatementNode(statementNode, context) {0
-  let containedAssertion = null;
+export function typeFromConstructorDeclarationNode(constructorDeclarationNode, context) {
+  let type;
 
-  const containedAssertionNode = statementNode.getContainedAssertionNode();
+  const typeNode = constructorDeclarationNode.getTypeNode();
 
-  if (containedAssertionNode !== null) {
-    containedAssertion = containedAssertionFromContainedAssertionNode(containedAssertionNode, context);
+  if (typeNode !== null) {
+    type = typeFromTypeNode(typeNode, context);
+  } else {
+    type = baseType;
   }
 
-  return containedAssertion;
+  return type;
 }
 
-export function statementFromContainedAssertionNode(containedAssertionNode, context) {
-  let statement = null;
+export function containedAssertionFromStatementNode(statementNode, context) {0
+  let containedAssertion = null;
 
-  const statementNode = containedAssertionNode.getStatementNode();
+  const containedAssertionNode = statementNode.getContainedAssertionNode();
 
-  if (statementNode !== null) {
-    statement = statementFromStatementNode(statementNode, context);
+  if (containedAssertionNode !== null) {
+    containedAssertion = containedAssertionFromContainedAssertionNode(containedAssertionNode, context);
   }
 
-  return statement;
+  return containedAssertion;
 }
 
 export function satisfiesAssertionFromStatementNode(statementNode, context) {
@@ -994,6 +1502,18 @@ export function satisfiesAssertionFromStatementNode(statementNode, context) {
   return satisfiesAssertion;
 }
 
+export function statementFromContainedAssertionNode(containedAssertionNode, context) {
+  let statement = null;
+
+  const statementNode = containedAssertionNode.getStatementNode();
+
+  if (statementNode !== null) {
+    statement = statementFromStatementNode(statementNode, context);
+  }
+
+  return statement;
+}
+
 export function propertyFromPropertyDeclarationNode(propertyDeclarationNode, context) {
   let property = null;
 
@@ -1021,10 +1541,10 @@ export function signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, cont
 export function referenceFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
   let reference = null;
 
-  const referenceNode = satisfiesAssertionNode.getReferenceNode();
+  const metavariableNode = satisfiesAssertionNode.getMetavariableNode();
 
-  if (referenceNode !== null) {
-    reference = referenceFromReferenceNode(referenceNode, context);
+  if (metavariableNode !== null) {
+    reference = referenceFromMetavariableNode(metavariableNode, context);
   }
 
   return reference;
@@ -1065,6 +1585,18 @@ export function metavariableFromFrameSubstitutionNode(frameSubstitutionNode, con
   return metavariable;
 }
 
+export function deductionFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
+  let deduction = null;
+
+  const deductionNode = metaLemmaMetathoremNode.getDeductionNode();
+
+  if (deductionNode !== null) {
+    deduction = deductionFromDeductionNode(deductionNode, context);
+  }
+
+  return deduction;
+}
+
 export function statementFromStatementSubstitutionNode(statementSubstitutionNode, context) {
   let statement = null;
 
@@ -1089,6 +1621,30 @@ export function referenceFromReferenceSubstitutionNode(referenceSubstitutionNode
   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;
+
+  const procedureReferenceNode = procedureCallNode.getProcedureReferenceNode();
+
+  if (procedureReferenceNode !== null) {
+    procedureReference = procedureReferenceFromProcedureReferenceNode(procedureReferenceNode, context);
+  }
+
+  return procedureReference;
+}
+
 export function typePrefixFromTypePrefixDeclarationNode(typePrefixDeclarationNode, context) {
   let typePrefix = null;
 
@@ -1128,6 +1684,18 @@ export function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationN
   return metaType;
 }
 
+export function proofFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
+  let proof = null;
+
+  const proofNode = axiomLemmaTheoremConjectureNode.getProofNode();
+
+  if (proofNode !== null) {
+    proof = proofFromProofNode(proofNode, context);
+  }
+
+  return proof;
+}
+
 export function propertyRelationFromPropertyAssertionNode(propertyAssertionNode, context) {
   let propertyRelation = null;
 
@@ -1179,18 +1747,6 @@ export function metavariableFromReferenceSubstitutionNode(referenceSubstitutionN
   return metavariable;
 }
 
-export function proofFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
-  let proof = null;
-
-  const proofNode = axiomLemmaTheoremConjectureNode.getProofNode();
-
-  if (proofNode !== null) {
-    proof = proofFromProofNode(proofNode, context);
-  }
-
-  return proof;
-}
-
 export function metavariableFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
   let metavariable = null;
 
@@ -1227,13 +1783,6 @@ export function signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremCo
   return signature;
 }
 
-export function suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
-  const suppositionNodes = axiomLemmaTheoremConjectureNode.getSuppositionNodes(),
-    suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);
-
-  return suppositions;
-}
-
 export function termsFromTermNodes(termNodes, context) {
   const terms = termNodes.map((termNode) => {
     const term = termFromTermNode(termNode, context);
@@ -1254,6 +1803,16 @@ export function labelsFromLabelNodes(labelNodes, context) {
   return labels;
 }
 
+export function premisesFromPremiseNodes(premiseNodes, context) {
+  const premises = premiseNodes.map((premiseNode) => {
+    const premise = premiseFromPremiseNode(premiseNode, context);
+
+    return premise;
+  });
+
+  return premises;
+}
+
 export function statementsFromStatementNodes(statementNodes, context) {
   const statements = statementNodes.map((statementNode) => {
     const statement = statementFromStatementNode(statementNode, context);
@@ -1283,6 +1842,26 @@ export function superTypesFromSuperTypeNodes(superTypeNodes, context) {
   return superTypes;
 }
 
+export function parametersFromParameterNodes(parameterNodes, context) {
+  const parameters = parameterNodes.map((parameterNode) => {
+    const parameter = parameterFromParameterNode(parameterNode, context);
+
+    return parameter;
+  });
+
+  return parameters;
+}
+
+export function hypothesesFromHypothesisNodes(hypothesisNodes, context) {
+  const hypotheses = hypothesisNodes.map((hypotheseNode) => {
+    const hypothesis = hypothesisFromHypothesisNode(hypotheseNode, context);
+
+    return hypothesis;
+  });
+
+  return hypotheses;
+}
+
 export function assumptionsFromAssumptionNodes(assumptionNodes, context) {
   const assumptions = assumptionNodes.map((assumptionNode) => {
     const assumption = assumptionFromAssumptionNode(assumptionNode, context);
@@ -1313,6 +1892,20 @@ export function propertiesFromPropertyDeclarationNodes(propertyDeclarationNodes,
   return properties;
 }
 
+export function labelsFromRuleNode(ruleNode, context) {
+  const labelNodes = ruleNode.getLabelNodes(),
+        labels = labelsFromLabelNodes(labelNodes, context);
+
+  return labels;
+}
+
+export function premisesFromRuleNode(ruleNode, context) {
+  const premiseNodes = ruleNode.getPremiseNodes(),
+        premises = premisesFromPremiseNodes(premiseNodes, context);
+
+  return premises;
+}
+
 export function termsFromSignatureNode(signatureNode, context) {
   const termNodes = signatureNode.getAssumptionNodes(),
         terms = termsFromTermNodes(termNodes, context);
@@ -1327,6 +1920,13 @@ export function assumptionsFromFrameNode(frameNode, context) {
   return assumptions;
 }
 
+export function termsFromEquivalenceNode(equivalenceNode, context) {
+  const termNodes = equivalenceNode.getTermNodes(),
+        terms = termsFromTermNodes(termNodes, context);
+
+  return terms;
+}
+
 export function suppositionsFromSubproofNode(subproofNode, context) {
   const suppositionNodes = subproofNode.getSuppositionNodes(),
         suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);
@@ -1334,6 +1934,13 @@ export function suppositionsFromSubproofNode(subproofNode, context) {
   return suppositions;
 }
 
+export function parametersFromProcedureCallNode(procedureCallNode, context) {
+  const parameterNodes = procedureCallNode.getParameterNodes(),
+        parameters = parametersFromParameterNodes(parameterNodes, context);
+
+  return parameters;
+}
+
 export function statementsFromSubproofAssertionNode(subproofAssertionNode, context) {
   const statementNodes = subproofAssertionNode.getStatementNodes(),
         statements = statementsFromStatementNodes(statementNodes, context);
@@ -1355,6 +1962,13 @@ export function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationN
   return superTypes;
 }
 
+export function suppositionsFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
+  const suppositionNodes = metaLemmaMetathoremNode.getSuppositionNodes(),
+        suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);
+
+  return suppositions;
+}
+
 export function labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
   const labelNodes = axiomLemmaTheoremConjectureNode.getLabelNodes(),
         labels = labelsFromLabelNodes(labelNodes, context);
@@ -1362,6 +1976,13 @@ export function labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConje
   return labels;
 }
 
+export function suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
+  const suppositionNodes = axiomLemmaTheoremConjectureNode.getSuppositionNodes(),
+        suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);
+
+  return suppositions;
+}
+