occam-verify-cli 1.0.437 → 1.0.444

package/src/utilities/element.js

@@ -2,11 +2,11 @@
 
 import elements from "../elements";
 
-import { baseType } from "../element/type";
+import { baseTypeFromNothing } from "../types";
 import { instantiateReference } from "../process/instantiate";
 import { equivalenceStringFromTerms,
-         subproofStringFromSubproofNode,
          rulsStringFromLabelsPremisesAndConclusion,
+         subproofStringFromSuppositionsAndSubDerivation,
          procedureCallStringFromProcedureReferenceAndParameters,
          sectionStringFromHypothesesAxiomLemmaTheoremAndConjecture,
          metaLemmaMetatheoremStringFromLabelSuppositionsAndDeduction,
@@ -16,7 +16,9 @@ export function typeFromTypeNode(typeNode, context) {
   let type;
 
   if (typeNode === null) {
-    type = baseType;
+    const baseType = baseTypeFromNothing();
+
+    type = baseType;  ///
   } else {
     const { Type } = elements,
           typeName = typeNode.getTypeName(),
@@ -40,8 +42,11 @@ export function termFromTermNode(termNode, context) {
   const { Term } = elements,
         node = termNode,  ///
         string = context.nodeAsString(node),
-        type = null,
-        term = new Term(context, string, node, type);
+        type = null;
+
+  context = null;
+
+  const term = new Term(context, string, node, type);
 
   return term;
 }
@@ -67,7 +72,7 @@ export function ruleFromRuleNode(ruleNode, context) {
         ruleString = rulsStringFromLabelsPremisesAndConclusion(labels, premises, conclusion),
         node = ruleNode,  ///
         string = ruleString,  ///
-        rule = new Rule(context, string, node, labels, premises, conclusion, proof);
+        rule = new Rule(context, string, node, proof, labels, premises, conclusion);
 
   return rule;
 }
@@ -237,13 +242,13 @@ export function variableFromVariableNode(variableNode, context) {
 }
 
 export function subproofFromSubproofNode(subproofNode, context) {
-  const { SubProof } = elements,
+  const { Subproof } = elements,
         node = subproofNode, ///
         suppositions = suppositionsFromSubproofNode(subproofNode, context),
         subDerivation = subDerivationFromSubproofNode(subproofNode, context),
-        subproofString = subproofStringFromSubproofNode(subproofNode, context),
+        subproofString = subproofStringFromSuppositionsAndSubDerivation(suppositions, subDerivation, context),
         string = subproofString,  ///
-        subproof = new SubProof(context, string, node, suppositions, subDerivation);
+        subproof = new Subproof(context, string, node, suppositions, subDerivation);
 
   return subproof;
 }
@@ -278,8 +283,11 @@ export function deductionFromDeductionNode(deductionNode, context) {
 export function statementFromStatementNode(statementNode, context) {
   const { Statement } = elements,
         node = statementNode, ///
-        string = context.nodeAsString(node),
-        statement = new Statement(context, string, node);
+        string = context.nodeAsString(node);
+
+  context = null;
+
+  const statement = new Statement(context, string, node);
 
   return statement;
 }
@@ -304,23 +312,6 @@ export function referenceFromReferenceNode(referenceNode, context) {
   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, ///
@@ -368,6 +359,33 @@ export function hypothesisFromHypothesisNode(hypotheseNode, context) {
   return parameter;
 }
 
+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),
+        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 combinatorFromCombinatorNode(combinatorNode, context) {
+  const { Combinator } = elements,
+        node = combinatorNode, ///
+        string = context.nodeAsString(node),
+        statement = statementFromCombinatorNode(combinatorNode, context),
+        combinator = new Combinator(context, string, node, statement);
+
+  return combinator;
+}
+
 export function conclusionFromConclusionNode(conclusionNode, context) {
   const { Conclusion } = elements,
         node = conclusionNode, ///
@@ -455,6 +473,16 @@ export function hyppothesisFromHypothesisNode(hypothesisNode, context) {
   return hypothesis
 }
 
+export function constructorFromConstructorNode(constructorNode, context) {
+  const { Constructor } = elements,
+        node = constructorNode, ///
+        string = context.nodeAsString(node),
+        term = termFromConstructorNode(constructorNode, context),
+        constructor = new Constructor(context, string, node, term);
+
+  return constructor;
+}
+
 export function suppositionFromSuppositionNode(suppositionNode, context) {
   const { Supposition } = elements,
         node = suppositionNode, ///
@@ -696,8 +724,8 @@ export function statementSubstitutionFromStatementSubstitutionNode(statementSubs
         node = statementSubstitutionNode,  ///
         string = context.nodeAsString(node),
         resolved = true,
-        statement = statementFromStatementSubstitutionNode(statementSubstitutionNode, context),
-        metavariable = metavariableFromStatementSubstitutionNode(statementSubstitutionNode, context),
+        statement = null,
+        metavariable = null,
         substitution = null,
         statementSubstitution = new StatementSubstitution(context, string, node, resolved, statement, metavariable, substitution);
 
@@ -870,6 +898,18 @@ export function derivationFromProofNode(proofNode, context) {
   return derivation;
 }
 
+export function termFromConstructorNode(ocnstructorNode, context) {
+  let term = null;
+
+  const termNode = ocnstructorNode.getTermNode();
+
+  if (termNode !== null) {
+    term = termFromTermNode(termNode, context);
+  }
+
+  return term;
+}
+
 export function statementFromPremiseNode(premiseNode, context) {
   let statement = null;
 
@@ -918,18 +958,6 @@ export function conclusionFromPremiseNode(premiseNode, 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;
 
@@ -985,6 +1013,18 @@ export function statementFromDeductionNode(deductionNode, context) {
   return statement;
 }
 
+export function judgementFromStatementNode(statementNode, context) {
+  let judgement = null;
+
+  const judgementNode = statementNode.getJudgementNode();
+
+  if (judgementNode !== null) {
+    judgement = judgementFromJudgementNode(judgementNode, context);
+  }
+
+  return judgement;
+}
+
 export function stepFromStepOrSubproofNode(stepOrSubproofNode, context) {
   let step = null;
 
@@ -999,6 +1039,18 @@ export function stepFromStepOrSubproofNode(stepOrSubproofNode, context) {
   return step;
 }
 
+export function statementFromCombinatorNode(combinatorNode, context) {
+  let statement = null;
+
+  const statementNode = combinatorNode.getStatementNode();
+
+  if (statementNode !== null) {
+    statement = statementFromStatementNode(statementNode, context);
+  }
+
+  return statement;
+}
+
 export function statementFromConclusionNode(conclusinoNode, context) {
   let statement = null;
 
@@ -1122,11 +1174,9 @@ export function termFromTermSubstitutionNode(termSubstitutionNode, context) {
 export function metavariableFromStatementNode(statementNode, context) {
   let metavariable = null;
 
-  const singularMetavariableNode = statementNode.getSingularMetavariableNode();
-
-  if (singularMetavariableNode !== null) {
-    const metavariableNode = singularMetavariableNode;  ///
+  const metavariableNode = statementNode.getMetavariableNode();
 
+  if (metavariableNode !== null) {
     metavariable = metavariableFromMetavariableNode(metavariableNode, context);
   }
 
@@ -1145,18 +1195,6 @@ export function subDerivationFromSubproofNode(subproofNode, context) {
   return subDerviation;
 }
 
-export function typeAssertinFromStatementNode(statementNode, context) {
-  let typeAssertion = null;
-
-  const typeAssertionNode = statementNode.getTypeAssertionNode();
-
-  if (typeAssertionNode !== null) {
-    typeAssertion = typeAssertionFromTypeAssertionNode(typeAssertionNode, context);
-  }
-
-  return typeAssertion;
-}
-
 export function metavariableFromReferenceNode(referenceNode, context) {
   let metavariable = null;
 
@@ -1211,6 +1249,18 @@ export function parameterNameFromParameterNode(parameterNode, context) {
   return parameterName;
 }
 
+export function typeAssertionFromStatementNode(statementNode, context) {
+  let typeAssertion = null;
+
+  const typeAssertionNode = statementNode.getTypeAssertionNode();
+
+  if (typeAssertionNode !== null) {
+    typeAssertion = typeAssertionFromTypeAssertionNode(typeAssertionNode, context);
+  }
+
+  return typeAssertion;
+}
+
 export function metavariableFromAssumptionNode(assumptionNode, context) {
   let metavariable = null;
 
@@ -1297,6 +1347,18 @@ export function frameFromContainedAssertionNode(containedAssertionNode, context)
   return frame;
 }
 
+export function procedureCallFromSuppositionNode(suppositionNode, context) {
+  let procedureCall = null;
+
+  const procedureCallNode = suppositionNode.getProcedureCallNode();
+
+  if (procedureCallNode !== null) {
+    procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
+  }
+
+  return procedureCall;
+}
+
 export function propertyFromPropertyRelationNode(propertyRelationNode, context) {
   let property = null;
 
@@ -1321,18 +1383,6 @@ export function variableFromTermSubstitutionNode(termSubstitutionNode, context)
   return variable;
 }
 
-export function procedureCallFromSuppositionNode(suppositionNode, context) {
-  let procedureCall = null;
-
-  const procedureCallNode = suppositionNode.getProcedureCallNode();
-
-  if (procedureCallNode !== null) {
-    procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
-  }
-
-  return procedureCall;
-}
-
 export function definedAssertionFromStatementNode(statementNode, context) {
   let definedAssertion = null;
 
@@ -1472,7 +1522,9 @@ export function typeFromConstructorDeclarationNode(constructorDeclarationNode, c
   if (typeNode !== null) {
     type = typeFromTypeNode(typeNode, context);
   } else {
-    type = baseType;
+    const baseType = baseTypeFromNothing();
+
+    type = baseType;  ///
   }
 
   return type;
@@ -1660,13 +1712,10 @@ export function typePrefixFromTypePrefixDeclarationNode(typePrefixDeclarationNod
 export function combinatorFromCombinatorDeclarationNode(combinatorDeclarationNode, context) {
   let combinator = null;
 
-  const statementNode = combinatorDeclarationNode.getStatementNode();
-
-  if (statementNode !== null) {
-    const { Combinator } = elements,
-      statement = statementFromStatementNode(statementNode, context);
+  const combinatorNode = combinatorDeclarationNode.getCombinatorNode();
 
-    combinator = new Combinator(statement);
+  if (combinatorNode !== null) {
+    combinator = combinatorFromCombinatorNode(combinatorNode, context);
   }
 
   return combinator;
@@ -1711,13 +1760,10 @@ export function propertyRelationFromPropertyAssertionNode(propertyAssertionNode,
 export function constructorFromConstructorDeclarationNode(constructorDeclarationNode, context) {
   let constructor = null;
 
-  const termNode = constructorDeclarationNode.getStatementNode();
-
-  if (termNode !== null) {
-    const { Constructor } = elements,
-          term = termFromTermNode(termNode, context);
+  const constructorNode = constructorDeclarationNode.getConstructorNode();
 
-    constructor = new Constructor(term);
+  if (constructorNode !== null) {
+    constructor = constructorFromConstructorNode(constructorNode, context);
   }
 
   return constructor;
@@ -1834,7 +1880,8 @@ export function superTypesFromSuperTypeNodes(superTypeNodes, context) {
         superTypesLength = superTypes.length;
 
   if (superTypesLength === 0) {
-    const superType = baseType; ///
+    const baseType = baseTypeFromNothing(),
+          superType = baseType; ///
 
     superTypes.push(superType);
   }
@@ -1948,6 +1995,13 @@ export function statementsFromSubproofAssertionNode(subproofAssertionNode, conte
   return statements;
 }
 
+export function suppositionsFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
+  const suppositionNodes = metaLemmaMetathoremNode.getSuppositionNodes(),
+        suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);
+
+  return suppositions;
+}
+
 export function propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
   const propertyDeclarationNodes = complexTypeDeclarationNode.getPropertyDeclarationNodes(),
         properties = propertiesFromPropertyDeclarationNodes(propertyDeclarationNodes, context);
@@ -1962,13 +2016,6 @@ 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);

package/src/utilities/instance.js

@@ -4,50 +4,50 @@ import nominalContext from "../context/nominal";
 
 import { BASE_TYPE_SYMBOL } from "../constants";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
-import { instantiateTerm, instantiateStatement } from "../process/instantiate";
-import { termFromTermNode, statementFromStatementNode } from "../utilities/element";
+import { instantiateCombinator, instantiateConstructor } from "../process/instantiate";
+import { combinatorFromCombinatorNode, constructorFromConstructorNode } from "../utilities/element";
 
-let bracketedConstructorTerm = null,
-    bracketedCombinatorStatement = null;
+let bracketedCombinator = null,
+    bracketedConstructor = null;
 
-export function bracketedConstructorTermFromNothing() {
-  if (bracketedConstructorTerm === null) {
+export function bracketedCombinatorFromNothing() {
+  if (bracketedCombinator === null) {
     let context;
 
-    const string = `(${BASE_TYPE_SYMBOL})`;
+    const string = `(${STATEMENT_META_TYPE_NAME})`;
 
     context = nominalContext; ///
 
-    const node = instantiateTerm(string, context),
-          bracketedConstructorTermNode = node;  ///
+    const combinatorNode = instantiateCombinator(string, context),
+          bracketedCombinatorNode = combinatorNode;  ///
 
     context = {
       nodeAsString: () => string
     };
 
-    bracketedConstructorTerm = termFromTermNode(bracketedConstructorTermNode, context);
+    bracketedCombinator = combinatorFromCombinatorNode(bracketedCombinatorNode, context);
   }
 
-  return bracketedConstructorTerm;
+  return bracketedCombinator;
 }
 
-export function bracketedCombinatorStatementFromNothing() {
-  if (bracketedCombinatorStatement === null) {
+export function bracketedConstructorFromNothing() {
+  if (bracketedConstructor === null) {
     let context;
 
-    const string = `(${STATEMENT_META_TYPE_NAME})`;
+    const string = `(${BASE_TYPE_SYMBOL})`;
 
     context = nominalContext; ///
 
-    const node = instantiateStatement(string, context),
-          bracketedCombinatorStatementNode = node;  ///
+    const constructorNode = instantiateConstructor(string, context),
+          bracketedConstructorNode = constructorNode;  ///
 
     context = {
       nodeAsString: () => string
     };
 
-    bracketedCombinatorStatement = statementFromStatementNode(bracketedCombinatorStatementNode, context);
+    bracketedConstructor = constructorFromConstructorNode(bracketedConstructorNode, context);
   }
 
-  return bracketedCombinatorStatement;
+  return bracketedConstructor;
 }

package/src/utilities/statement.js

@@ -1,75 +1,74 @@
 "use strict";
 
-import elements from "../elements";
+import { equalityFromStatementNode,
+         judgementFromStatementNode,
+         metavariableFromStatementNode,
+         typeAssertionFromStatementNode,
+         definedAssertionFromStatementNode,
+         propertyAssertionFromStatementNode,
+         subproofAssertionFromStatementNode,
+         containedAssertionFromStatementNode,
+         satisfiesAssertionFromStatementNode } from "../utilities/element";
 
 export function equalityFromStatement(statement, context) {
-  const { Equality } = elements,
-        statementNode = statement.getNode(),
-        equality = Equality.fromStatementNode(statementNode, context);
+  const statementNode = statement.getNode(),
+        equality = equalityFromStatementNode(statementNode, context);
 
   return equality;
 }
 
 export function judgementFromStatement(statement, context) {
-  const { Judgement } = elements,
-        statementNode = statement.getNode(),
-        judgement = Judgement.fromStatementNode(statementNode, context);
+  const statementNode = statement.getNode(),
+        judgement = judgementFromStatementNode(statementNode, context);
 
   return judgement;
 }
 
 export function metavariableFromStatement(statement, context) {
-  const { Metavariable } = elements,
-        statementNode = statement.getNode(),
-        metavariable = Metavariable.fromStatementNode(statementNode, context);
+  const statementNode = statement.getNode(),
+        metavariable = metavariableFromStatementNode(statementNode, context);
 
   return metavariable;
 }
 
 export function typeAssertionFromStatement(statement, context) {
-  const { TypeAssertion } = elements,
-        statementNode = statement.getNode(),
-        typeAssertion = TypeAssertion.fromStatementNode(statementNode, context);
+  const statementNode = statement.getNode(),
+        typeAssertion = typeAssertionFromStatementNode(statementNode, context);
 
   return typeAssertion;
 }
 
 export function definedAssertionFromStatement(statement, context) {
-  const { DefinedAssertion } = elements,
-        statementNode = statement.getNode(),
-        definedAssertion = DefinedAssertion.fromStatementNode(statementNode, context);
+  const statementNode = statement.getNode(),
+        definedAssertion = definedAssertionFromStatementNode(statementNode, context);
 
   return definedAssertion;
 }
 
 export function propertyAssertionFromStatement(statement, context) {
-  const { PropertyAssertion } = elements,
-        statementNode = statement.getNode(),
-        propertyAssertion = PropertyAssertion.fromStatementNode(statementNode, context);
+  const statementNode = statement.getNode(),
+        propertyAssertion = propertyAssertionFromStatementNode(statementNode, context);
 
   return propertyAssertion;
 }
 
 export function subproofAssertionFromStatement(statement, context) {
-  const { SubproofAssertion } = elements,
-        statementNode = statement.getNode(),
-        subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, context);
+  const statementNode = statement.getNode(),
+        subproofAssertion = subproofAssertionFromStatementNode(statementNode, context);
 
   return subproofAssertion;
 }
 
 export function containedAssertionFromStatement(statement, context) {
-  const { ContainedAssertion } = elements,
-        statementNode = statement.getNode(),
-        containedAssertion = ContainedAssertion.fromStatementNode(statementNode, context);
+  const statementNode = statement.getNode(),
+        containedAssertion = containedAssertionFromStatementNode(statementNode, context);
 
   return containedAssertion;
 }
 
 export function satisfiesAssertionFromStatement(statement, context) {
-  const { SatisfiesAssertion } = elements,
-        statementNode = statement.getNode(),
-        satisfiesAssertion = SatisfiesAssertion.fromStatementNode(statementNode, context);
+  const statementNode = statement.getNode(),
+        satisfiesAssertion = satisfiesAssertionFromStatementNode(statementNode, context);
 
   return satisfiesAssertion;
 }

package/src/utilities/string.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { baseType } from "../element/type";
+import { baseTypeFromNothing } from "../types";
 
 export function termsStringFromTerms(terms) {
   const termsString = terms.reduce((termsString, term) => {
@@ -59,17 +59,18 @@ export function hypothesesStringFromHypotheses(hypotheses, context) {
 }
 
 export function superTypesStringFromSuperTypes(superTypes) {
-  const superTypesString = superTypes.reduce((superTypesString, superType) => {
-    if (superType !== baseType) {
-      const superTypeString = superType.getString();
+  const baseType = baseTypeFromNothing(),
+        superTypesString = superTypes.reduce((superTypesString, superType) => {
+          if (superType !== baseType) {
+            const superTypeString = superType.getString();
 
-      superTypesString = (superTypesString === null) ?
-                           `'${superTypeString}'` :
-                             `${superTypesString}, '${superTypeString}'`;
-    }
+            superTypesString = (superTypesString === null) ?
+                                 `'${superTypeString}'` :
+                                   `${superTypesString}, '${superTypeString}'`;
+          }
 
-    return superTypesString;
-  }, null);
+          return superTypesString;
+        }, null);
 
   return superTypesString;
 }
@@ -116,6 +117,20 @@ export function suppositionsStringFromSuppositions(suppositions) {
   return suppositionsString;
 }
 
+export function substitutionsStringFromSubstitutions(substitutions) {
+  const substitutionsString = substitutions.reduce((substitutionsString, substitution) => {
+    const substitutionString = substitution.getString();
+
+    substitutionsString = (substitutionsString === null) ?
+                             substitutionString : ///
+                              `${substitutionsString}, ${substitutionString}`;
+
+    return substitutionsString;
+  }, null);
+
+  return substitutionsString;
+}
+
 export function signatureStringFromTerms(terms) {
   const termsString = termsStringFromTerms(terms),
         signatureString = `[${termsString}]`;
@@ -130,16 +145,6 @@ export function equivalenceStringFromTerms(terms) {
   return equivalenceString;
 }
 
-export function subproofStringFromSubproof(subproof) {
-  const lastStep = subproof.getLastStep(),
-        suppositions = subproof.getSuppositions(),
-        lastStepString = lastStep.getString(),
-        suppositionsString = suppositionsStringFromSuppositions(suppositions),
-        subproofString = `[${suppositionsString}] ... ${lastStepString}`;
-
-  return subproofString;
-}
-
 export function rulsStringFromLabelsPremisesAndConclusion(labels, premises, conclusion) {
   const premisesString = premisesStringFromPremises(premises),
         conclusionString = conclusion.getString(),
@@ -151,6 +156,15 @@ export function rulsStringFromLabelsPremisesAndConclusion(labels, premises, conc
   return ruleString;
 }
 
+export function subproofStringFromSuppositionsAndSubDerivation(suppositions, subDerivation) {
+  const lastStep = subDerivation.getLastStep(),
+        lastStepString = lastStep.getString(),
+        suppositionsString = suppositionsStringFromSuppositions(suppositions),
+        subproofString = `[${suppositionsString}] ... ${lastStepString}`;
+
+  return subproofString;
+}
+
 export function typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes) {
   let typeString;