occam-verify-cli 1.0.457 → 1.0.473

package/src/utilities/element.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import elements from "../elements";
-import FragmentContext from "../context/fragment";
 
+import { literally } from "../utilities/context";
 import { baseTypeFromNothing } from "../types";
 import { instantiateReference } from "../process/instantiate";
 import { findMetaTypeByMetaTypeName } from "../metaTypes";
@@ -44,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;
 }
@@ -106,7 +103,7 @@ export function lemmaFromLemmaNode(lemmaNode, context) {
         deduction = deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
-        hypotheses = [],
+        hypotheses = hypothesesFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = lemmaNode, ///
         string = topLevelAsssertionString, ///
@@ -138,7 +135,7 @@ export function proofFromProofNode(proofNode, context) {
 export function axiomFromAxiomNode(axiomNode, context) {
   const { Axiom } = elements,
         topLevelAsssertionNode = axiomNode,  ///
-        proof = null,
+        proof = proofFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         labels = labelsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         deduction = deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
@@ -159,7 +156,7 @@ export function sectionFromSectionNode(sectionNode, context) {
         lemma = lemmaFromSectionNode(sectionNode, context),
         theorem = theoremFromSectionNode(sectionNode, context),
         conjecture = conjectureFromSectionNode(sectionNode, context),
-        sectionString = sectionStringFromHypothesesTopLevelAssertion(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);
@@ -195,19 +192,6 @@ export function theoremFromTheoremNode(theoremNode, context) {
   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 metaTypeName = metaTypeNode.getMetaTypeName(),
         metaType = findMetaTypeByMetaTypeName(metaTypeName);
@@ -281,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;
 }
@@ -339,11 +320,11 @@ export function metaLemmaFromMetaLemmaNode(metaLemmaNode, context) {
 
 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);
+        node = parameterNode, ///
+        string = context.nodeAsString(node),
+        name = parameterNode.getName(),
+        identifier = parameterNode.getIdentifier(),
+        parameter = new Parameter(context, string, node, name, identifier);
 
   return parameter;
 }
@@ -395,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, ///
@@ -437,41 +408,6 @@ export function typePrefixFromTypePrefixNode(typePrefixNode, context) {
   return typePrefix;
 }
 
-export function referenceFromMetavariableNode(metavariableNode, context) {
-  const metavariableString = context.nodeAsString(metavariableNode),
-        referenceString = metavariableString, ///
-        string = referenceString,  ///
-        fragmentContext = FragmentContext.fromNothing(context);
-
-  context = fragmentContext;  ///
-
-  const 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 substitutionFromParameterNode(substitutionNode, context) {
-  const { Substitution } = elements,
-    node = substitutionNode, ///
-    string = context.nodeAsString(node),
-    substitutionName = substitutionNode.getSubstitutionName(),
-    name = substitutionName,  ///
-    substitution = new Substitution(context, string, node, name);
-
-  return substitution;
-}
-
 export function constructorFromConstructorNode(constructorNode, context) {
   const { Constructor } = elements,
         node = constructorNode, ///
@@ -520,12 +456,6 @@ export function metatheoremFromMetatheoremNode(metatheoremNode, context) {
   return metatheorem;
 }
 
-export function nameFromProcedureReferenceNode(procedureReferenceNode, context) {
-  const name = procedureReferenceNode.getName();
-
-  return name;
-}
-
 export function metavariableFromMetavariableNode(metavariableNode, context) {
   const { Metavariable } = elements,
         node = metavariableNode,  ///
@@ -581,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,  ///
@@ -620,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;
 }
@@ -631,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;
 }
@@ -743,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 = statementFromStatementSubstitutionNode(statementSubstitutionNode, context),
-        metavariable = metavariableFromStatementSubstitutionNode(statementSubstitutionNode, context),
-        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, ///
@@ -802,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;
 
@@ -838,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;
 
@@ -970,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;
 
@@ -1006,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;  ///
@@ -1063,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;
 
@@ -1111,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;
 
@@ -1183,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) {
@@ -1207,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;
 
@@ -1231,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);
@@ -1267,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;
 
@@ -1285,42 +1173,6 @@ 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;
-
-  const frameNode = frameSubstitutionNode.getFrameNode();
-
-  if (frameNode !== null) {
-    frame = frameFromFrameNode(frameNode, context);
-  }
-
-  return frame;
-}
-
 export function proofFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
   let proof = null;
 
@@ -1359,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) {
@@ -1407,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;
 
@@ -1455,6 +1289,18 @@ export function typeFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, con
   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;
 
@@ -1515,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;
 
@@ -1550,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) {
@@ -1574,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;
 
@@ -1626,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;
 
@@ -1662,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;
+}
+
+export function targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
+  let targetFrame = null;
 
-  const variableNode = variableDeclarationNode.getVariableNode();
+  const targetFrameNode = frameSubstitutionNode.getTargetFrameNode();
 
-  if (variableNode !== null) {
-    variable = variableFromVariableNode(variableNode, context);
+  if (targetFrameNode !== null) {
+    targetFrame = frameFromFrameNode(targetFrameNode, context);
   }
 
-  return variable;
+  return targetFrame;
 }
 
 export function stepsOrSubproofsFromSubDerivationNode(subDerivationNode, context) {
@@ -1685,16 +1497,22 @@ 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 prefixedFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
+  const prefixed = complexTypeDeclarationNode.isPrefixed();
+
+  return prefixed;
 }
 
 export function deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
@@ -1709,42 +1527,6 @@ export function deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode,
   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;
 
@@ -1757,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;
 
@@ -1793,6 +1587,18 @@ export function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationN
   return metaType;
 }
 
+export function replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
+  let replacementFrame = null;
+
+  const replacementFrameNode = frameSubstitutionNode.getReplacementFrameNode();
+
+  if (replacementFrameNode !== null) {
+    replacementFrame = frameFromFrameNode(replacementFrameNode, context);
+  }
+
+  return replacementFrame;
+}
+
 export function propertyRelationFromPropertyAssertionNode(propertyAssertionNode, context) {
   let propertyRelation = null;
 
@@ -1817,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);
@@ -1829,28 +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 replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
+  let replacementReference = null;
+
+  const replacementReferenceNode = referenceSubstitutionNode.getReplacementReferenceNode();
+
+  if (replacementReferenceNode !== null) {
+    replacementReference = referenceFromReferenceNode(replacementReferenceNode, context);
+  }
+
+  return replacementReference;
+}
+
+export function replacementStatementFromStatementSubstitutionNode(statementSubstitutionNode, context) {
+  let replacementStatement = null;
+
+  const replacementStatementNode = statementSubstitutionNode.getReplacementStatementNode();
+
+  if (replacementStatementNode !== null) {
+    replacementStatement = statementFromStatementNode(replacementStatementNode, context);
+  }
+
+  return replacementStatement;
 }
 
 export function termsFromTermNodes(termNodes, context) {
@@ -1893,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);
@@ -1953,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);
@@ -2033,20 +1833,6 @@ export function suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, co
   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 suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
   const suppositionNodes = metaLemmaMetathoremNode.getSuppositionNodes(),
         suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);