occam-verify-cli 1.0.448 → 1.0.457

package/src/utilities/element.js

@@ -1,16 +1,18 @@
 "use strict";
 
 import elements from "../elements";
+import FragmentContext from "../context/fragment";
 
 import { baseTypeFromNothing } from "../types";
 import { instantiateReference } from "../process/instantiate";
+import { findMetaTypeByMetaTypeName } from "../metaTypes";
 import { equivalenceStringFromTerms,
          rulsStringFromLabelsPremisesAndConclusion,
+         sectionStringFromHypothesesTopLevelAssertion,
          subproofStringFromSuppositionsAndSubDerivation,
          procedureCallStringFromProcedureReferenceAndParameters,
-         sectionStringFromHypothesesAxiomLemmaTheoremAndConjecture,
-         metaLemmaMetatheoremStringFromLabelSuppositionsAndDeduction,
-         axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction } from "../utilities/string";
+         topLevelAssertionStringFromLabelsSuppositionsAndDeduction,
+         topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
 
 export function typeFromTypeNode(typeNode, context) {
   let type;
@@ -98,16 +100,16 @@ export function errorFromErrorNode(errorNode, context) {
 
 export function lemmaFromLemmaNode(lemmaNode, context) {
   const { Lemma } = elements,
-        axiomLemmaTheoremConjectureNode = lemmaNode,  ///
-        proof = proofFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        labels = labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        deduction = deductionFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        suppositions = suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        signature = signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
+        topLevelAsssertionNode = lemmaNode,  ///
+        proof = proofFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        labels = labelsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        deduction = deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         hypotheses = [],
-        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = lemmaNode, ///
-        string = axiomLemmaTheoremConjectureString, ///
+        string = topLevelAsssertionString, ///
         lemma = new Lemma(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
   return lemma;
@@ -115,10 +117,10 @@ export function lemmaFromLemmaNode(lemmaNode, context) {
 
 export function frameFromFrameNode(frameNode, context) {
   const { Frame } = elements,
-    node = frameNode, ///
-    string = context.nodeAsString(node),
-    assumptions = assumptionsFromFrameNode(frameNode, context),
-    frame = new Frame(context, string, node, assumptions);
+        node = frameNode, ///
+        string = context.nodeAsString(node),
+        assumptions = assumptionsFromFrameNode(frameNode, context),
+        frame = new Frame(context, string, node, assumptions);
 
   return frame;
 }
@@ -135,16 +137,16 @@ export function proofFromProofNode(proofNode, context) {
 
 export function axiomFromAxiomNode(axiomNode, context) {
   const { Axiom } = elements,
-        axiomLemmaTheoremConjectureNode = axiomNode,  ///
+        topLevelAsssertionNode = axiomNode,  ///
         proof = null,
-        labels = labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        deduction = deductionFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        suppositions = suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        signature = signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
+        labels = labelsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        deduction = deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         hypotheses = [],
-        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = axiomNode, ///
-        string = axiomLemmaTheoremConjectureString, ///
+        string = topLevelAsssertionString, ///
         axiom = new Axiom(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
   return axiom;
@@ -157,7 +159,7 @@ export function sectionFromSectionNode(sectionNode, context) {
         lemma = lemmaFromSectionNode(sectionNode, context),
         theorem = theoremFromSectionNode(sectionNode, context),
         conjecture = conjectureFromSectionNode(sectionNode, context),
-        sectionString = sectionStringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context),
+        sectionString = sectionStringFromHypothesesTopLevelAssertion(hypotheses, axiom, lemma, theorem, conjecture, context),
         node = sectionNode, ///
         string = sectionString, ///
         section = new Section(context, string, node, hypotheses, axiom, lemma, theorem, conjecture);
@@ -178,16 +180,16 @@ export function premiseFromPremiseNode(premiseNode, context) {
 
 export function theoremFromTheoremNode(theoremNode, context) {
   const { Theorem } = elements,
-        axiomLemmaTheoremConjectureNode = theoremNode,  ///
-        proof = proofFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        labels = labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        deduction = deductionFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        suppositions = suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        signature = signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
+        topLevelAsssertionNode = theoremNode,  ///
+        proof = proofFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        labels = labelsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        deduction = deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         hypotheses = [],
-        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = theoremNode, ///
-        string = axiomLemmaTheoremConjectureString, ///
+        string = topLevelAsssertionString, ///
         theorem = new Theorem(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
   return theorem;
@@ -207,24 +209,20 @@ export function equalityFromEqualityNode(equalityNode, context) {
 }
 
 export function metaTypeFromMetaTypeNode(metaTypeNode, context) {
-  const { MetaType } = elements,
-        node = metaTypeNode,  ///
-        string = context.nodeAsString(node),
-        metaTypeName = metaTypeNode.getMetaTypeName(),
-        name = metaTypeName,  ///
-        metaType = new MetaType(context, string, node, name);
+  const metaTypeName = metaTypeNode.getMetaTypeName(),
+        metaType = findMetaTypeByMetaTypeName(metaTypeName);
 
   return metaType;
 }
 
 export function propertyFromPropertyNode(propertyNode, context) {
   const { Property } = elements,
-    node = propertyNode, ///
-    string = context.nodeAsString(node),
-    propertyName = propertyNode.getPropertyName(),
-    nominalTypeName = null,
-    name = propertyName,  ///
-    property = new Property(context, string, node, name, nominalTypeName);
+        node = propertyNode, ///
+        string = context.nodeAsString(node),
+        propertyName = propertyNode.getPropertyName(),
+        nominalTypeName = null,
+        name = propertyName,  ///
+        property = new Property(context, string, node, name, nominalTypeName);
 
   return property;
 }
@@ -326,13 +324,14 @@ export function judgementFromJudgementNode(judgementNode, context) {
 export function metaLemmaFromMetaLemmaNode(metaLemmaNode, context) {
   const { MetaLemma } = elements,
         metaLemmaMetathoremNode = metaLemmaNode,  ///
-        proof = proofFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        label = labelFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        deduction = deductionFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        suppositions = suppositionsFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
+        proof = proofFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        label = labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        deduction = deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        suppositions = suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
         substitutions = null,
         node = metaLemmaNode, ///
-        string = metaLemmaMetatheoremStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
+        string = topLevelMetaAssertionString, ///
         metaLemma = new MetaLemma(context, string, node, label, suppositions, deduction, proof, substitutions);
 
   return metaLemma;
@@ -340,11 +339,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),
+    parameterName = parameterNode.getParameterName(),
+    name = parameterName,  ///
+    parameter = new Parameter(context, string, node, name);
 
   return parameter;
 }
@@ -361,16 +360,16 @@ export function hypothesisFromHypothesisNode(hypotheseNode, context) {
 
 export function conjectureFromConjectureNode(conjectureNode, context) {
   const { Conjecture } = elements,
-        axiomLemmaTheoremConjectureNode = conjectureNode,  ///
-        proof = proofFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        labels = labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        deduction = deductionFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        suppositions = suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
-        signature = signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context),
+        topLevelAsssertionNode = conjectureNode,  ///
+        proof = proofFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        labels = labelsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        deduction = deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
+        signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         hypotheses = [],
-        axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
         node = conjectureNode, ///
-        string = axiomLemmaTheoremConjectureString, ///
+        string = topLevelAsssertionString, ///
         conjecture = new Conjecture(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
   return conjecture;
@@ -438,26 +437,15 @@ export function typePrefixFromTypePrefixNode(typePrefixNode, context) {
   return typePrefix;
 }
 
-export function metatheoremFromMetaLemmaNode(metatheoremNode, context) {
-  const { Metatehorem } = elements,
-        metaLemmaMetathoremNode = metatheoremNode,  ///
-        proof = proofFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        label = labelFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        deduction = deductionFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        suppositions = suppositionsFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context),
-        substitutions = null,
-        node = metaLemmaNode, ///
-        string = metaLemmaMetatheoremStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
-        metatheorem = new Metatehorem(context, string, node, label, suppositions, deduction, proof, substitutions);
-
-  return metatheorem;
-}
-
 export function referenceFromMetavariableNode(metavariableNode, context) {
   const metavariableString = context.nodeAsString(metavariableNode),
         referenceString = metavariableString, ///
         string = referenceString,  ///
-        referenceNode = instantiateReference(string, context),
+        fragmentContext = FragmentContext.fromNothing(context);
+
+  context = fragmentContext;  ///
+
+  const referenceNode = instantiateReference(string, context),
         reference = referenceFromReferenceNode(referenceNode, context);
 
   return reference;
@@ -473,6 +461,17 @@ export function hyppothesisFromHypothesisNode(hypothesisNode, context) {
   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, ///
@@ -505,6 +504,22 @@ export function equivalenceFromEquivalenceNode(equivalenceNode, context) {
   return equivalence;
 }
 
+export function metatheoremFromMetatheoremNode(metatheoremNode, context) {
+  const { Metatehorem } = elements,
+        metaLemmaMetathoremNode = metatheoremNode,  ///
+        proof = proofFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        label = labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        deduction = deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        suppositions = suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context),
+        topLevelMetaAssertionString = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
+        substitutions = null,
+        node = metaLemmaNode, ///
+        string = topLevelMetaAssertionString, ///
+        metatheorem = new Metatehorem(context, string, node, label, suppositions, deduction, proof, substitutions);
+
+  return metatheorem;
+}
+
 export function nameFromProcedureReferenceNode(procedureReferenceNode, context) {
   const name = procedureReferenceNode.getName();
 
@@ -673,17 +688,26 @@ export function procedureReferenceFromProcedureReferenceNode(procedureReferenceN
         node = procedureReferenceNode,  ///
         string = context.nodeAsString(node),
         name = nameFromProcedureReferenceNode(procedureReferenceNode, context),
-        variableDeclaration = new ProcedureReference(context, string, node, name);
+        procedureDeclaration = new ProcedureReference(context, string, node, name);
 
-  return variableDeclaration;
+  return procedureDeclaration;
 }
 
 export function variableDeclarationFromVariableDeclarationNode(variableDeclarationNode, context) {
   const { VariableDeclaration } = elements,
         node = variableDeclarationNode,  ///
         string = context.nodeAsString(node),
-        variable = variableFromVariableNode(variableDeclarationNode, context),
-        variableDeclaration = new VariableDeclaration(context, string, node, variable);
+        typeNode = variableDeclarationNode.getTypeNode(),
+        provisional = variableDeclarationNode.isProvisional(),
+        variableNode = variableDeclarationNode.getVariableNode(),
+        type = typeFromTypeNode(typeNode, context),
+        variable = variableFromVariableNode(variableNode, context);
+
+  type.setProvisional(provisional);
+
+  variable.setType(type);
+
+  const variableDeclaration = new VariableDeclaration(context, string, node, variable);
 
   return variableDeclaration;
 }
@@ -724,8 +748,8 @@ export function statementSubstitutionFromStatementSubstitutionNode(statementSubs
         node = statementSubstitutionNode,  ///
         string = context.nodeAsString(node),
         resolved = true,
-        statement = null,
-        metavariable = null,
+        statement = statementFromStatementSubstitutionNode(statementSubstitutionNode, context),
+        metavariable = metavariableFromStatementSubstitutionNode(statementSubstitutionNode, context),
         substitution = null,
         statementSubstitution = new StatementSubstitution(context, string, node, resolved, statement, metavariable, substitution);
 
@@ -1297,6 +1321,18 @@ export function frameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
   return frame;
 }
 
+export function proofFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
+  let proof = null;
+
+  const proofNode = topLevelAsssertionNode.getProofNode();
+
+  if (proofNode !== null) {
+    proof = proofFromProofNode(proofNode, context);
+  }
+
+  return proof;
+}
+
 export function subproofFromStepOrSubproofNode(subproofOrSubproofNode, context) {
   let subproof = null;
 
@@ -1407,7 +1443,43 @@ export function termSubstitutionFromStatementNode(statementNode, context) {
   return termSubstitution;
 }
 
-export function proofFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
+export function typeFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
+  let type = null;
+
+  const typeNode = simpleTypeDeclarationNode.getTypeNode();
+
+  if (typeNode !== null) {
+    type = typeFromTypeNode(typeNode, context);
+  }
+
+  return type;
+}
+
+export function deductionFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
+  let deduction = null;
+
+  const deductionNode = topLevelAsssertionNode.getDeductionNode();
+
+  if (deductionNode !== null) {
+    deduction = deductionFromDeductionNode(deductionNode, context);
+  }
+
+  return deduction;
+}
+
+export function signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
+  let signature = null;
+
+  const signatureNode = topLevelAsssertionNode.getSignatureNode();
+
+  if (signatureNode !== null) {
+    signature = signatureFromSignatureNode(signatureNode, context);
+  }
+
+  return signature;
+}
+
+export function proofFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
   let proof = null;
 
   const proofNode = metaLemmaMetathoremNode.getProofNode();
@@ -1419,7 +1491,7 @@ export function proofFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, conte
   return proof;
 }
 
-export function labelFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
+export function labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
   let label = null;
 
   const labelNode = metaLemmaMetathoremNode.getLabelNode();
@@ -1431,18 +1503,6 @@ export function labelFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, conte
   return label;
 }
 
-export function typeFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
-  let type = null;
-
-  const typeNode = simpleTypeDeclarationNode.getTypeNode();
-
-  if (typeNode !== null) {
-    type = typeFromTypeNode(typeNode, context);
-  }
-
-  return type;
-}
-
 export function frameSubstitutionFromStatementNode(statementNode, context) {
   let frameSubstitution = null;
 
@@ -1637,7 +1697,7 @@ export function metavariableFromFrameSubstitutionNode(frameSubstitutionNode, con
   return metavariable;
 }
 
-export function deductionFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
+export function deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
   let deduction = null;
 
   const deductionNode = metaLemmaMetathoremNode.getDeductionNode();
@@ -1733,18 +1793,6 @@ 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;
 
@@ -1805,30 +1853,6 @@ export function metavariableFromMetavariableDeclarationNode(metavariableDeclarat
   return metavariable;
 }
 
-export function deductionFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
-  let deduction = null;
-
-  const deductionNode = axiomLemmaTheoremConjectureNode.getDeductionNode();
-
-  if (deductionNode !== null) {
-    deduction = deductionFromDeductionNode(deductionNode, context);
-  }
-
-  return deduction;
-}
-
-export function signatureFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
-  let signature = null;
-
-  const signatureNode = axiomLemmaTheoremConjectureNode.getSignatureNode();
-
-  if (signatureNode !== null) {
-    signature = signatureFromSignatureNode(signatureNode, context);
-  }
-
-  return signature;
-}
-
 export function termsFromTermNodes(termNodes, context) {
   const terms = termNodes.map((termNode) => {
     const term = termFromTermNode(termNode, context);
@@ -1988,6 +2012,13 @@ export function parametersFromProcedureCallNode(procedureCallNode, context) {
   return parameters;
 }
 
+export function labelsFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
+  const labelNodes = topLevelAsssertionNode.getLabelNodes(),
+        labels = labelsFromLabelNodes(labelNodes, context);
+
+  return labels;
+}
+
 export function statementsFromSubproofAssertionNode(subproofAssertionNode, context) {
   const statementNodes = subproofAssertionNode.getStatementNodes(),
         statements = statementsFromStatementNodes(statementNodes, context);
@@ -1995,8 +2026,8 @@ export function statementsFromSubproofAssertionNode(subproofAssertionNode, conte
   return statements;
 }
 
-export function suppositionsFromMetaLemmaMetatheoremNode(metaLemmaMetathoremNode, context) {
-  const suppositionNodes = metaLemmaMetathoremNode.getSuppositionNodes(),
+export function suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
+  const suppositionNodes = topLevelAsssertionNode.getSuppositionNodes(),
         suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);
 
   return suppositions;
@@ -2016,33 +2047,9 @@ export function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationN
   return superTypes;
 }
 
-export function labelsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
-  const labelNodes = axiomLemmaTheoremConjectureNode.getLabelNodes(),
-        labels = labelsFromLabelNodes(labelNodes, context);
-
-  return labels;
-}
-
-export function suppositionsFromAxiomLemmaTheoremConjectureNode(axiomLemmaTheoremConjectureNode, context) {
-  const suppositionNodes = axiomLemmaTheoremConjectureNode.getSuppositionNodes(),
+export function suppositionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
+  const suppositionNodes = metaLemmaMetathoremNode.getSuppositionNodes(),
         suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context);
 
   return suppositions;
 }
-
-
-
-
-export function _typeFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
-  let type = null;
-
-  const typeNode = metavariableDeclarationNode.getTypeNode();
-
-  if (typeNode !== null) {
-    const nominalTypeName = typeNode.getNominalTypeName();
-
-    type = context.findTypeByNominalTypeName(nominalTypeName);
-  }
-
-  return type;
-}

package/src/utilities/fragment.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import FragmentContext from "../context/fragment";
+
+export function withinFragment(innerFunction, context) {
+  const fragmentContext = FragmentContext.fromNothing(context);
+
+  context = fragmentContext;  ///
+
+  return innerFunction(context);
+}

package/src/utilities/instance.js

@@ -2,7 +2,7 @@
 
 import nominalContext from "../context/nominal";
 
-import { getMetaTypes } from "../metaTypes";
+import { withinFragment } from "../utilities/fragment";
 import { BASE_TYPE_SYMBOL } from "../constants";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 import { instantiateCombinator, instantiateConstructor } from "../process/instantiate";
@@ -13,18 +13,17 @@ let bracketedCombinator = null,
 
 export function bracketedCombinatorFromNothing() {
   if (bracketedCombinator === null) {
-    let context;
+    const context = nominalContext; ///
 
-    const string = `(${STATEMENT_META_TYPE_NAME})`;
+    bracketedCombinator = withinFragment((context) => {
+      const bracketedCombinatorString = `(${STATEMENT_META_TYPE_NAME})`,
+            string = bracketedCombinatorString, ///
+            combinatorNode = instantiateCombinator(string, context),
+            bracketedCombinatorNode = combinatorNode,  ///
+            bracketedCombinator = combinatorFromCombinatorNode(bracketedCombinatorNode, context);
 
-    context = nominalContext; ///
-
-    const combinatorNode = instantiateCombinator(string, context),
-          bracketedCombinatorNode = combinatorNode;  ///
-
-    context = contextFromString(string);
-
-    bracketedCombinator = combinatorFromCombinatorNode(bracketedCombinatorNode, context);
+      return bracketedCombinator;
+    }, context);
   }
 
   return bracketedCombinator;
@@ -32,40 +31,18 @@ export function bracketedCombinatorFromNothing() {
 
 export function bracketedConstructorFromNothing() {
   if (bracketedConstructor === null) {
-    let context;
-
-    const string = `(${BASE_TYPE_SYMBOL})`;
-
-    context = nominalContext; ///
-
-    const constructorNode = instantiateConstructor(string, context),
-          bracketedConstructorNode = constructorNode;  ///
+    const context = nominalContext; ///
 
-    context = contextFromString(string);
+    bracketedConstructor = withinFragment((context) => {
+      const bracketedConstructorString = `(${BASE_TYPE_SYMBOL})`,
+            string = bracketedConstructorString,  ///
+            constructorNode = instantiateConstructor(string, context),
+            bracketedConstructorNode = constructorNode, ///
+            bracketedConstructor = constructorFromConstructorNode(bracketedConstructorNode, context);
 
-    bracketedConstructor = constructorFromConstructorNode(bracketedConstructorNode, context);
+      return bracketedConstructor;
+    }, context);
   }
 
   return bracketedConstructor;
 }
-
-function contextFromString(string) {
-  const context = {
-    nodeAsString: () => string,
-    getMetaTypes: () => getMetaTypes(),
-    findMetaTypeByMetaTypeName(metaTypeName) {
-      const metaTypes = this.getMetaTypes(),
-            metaType = metaTypes.find((metaType) => {
-              const metaTypeComparesToMetaTypeName = metaType.compareMetaTypeName(metaTypeName);
-
-              if (metaTypeComparesToMetaTypeName) {
-                return true;
-              }
-            }) || null;
-
-      return metaType;
-    }
-  };
-
-  return context;
-}

package/src/utilities/json.js

@@ -2,6 +2,8 @@
 
 import elements from "../elements";
 
+import { findMetaTypeByMetaTypeName } from "../metaTypes";
+
 export function termFromJSON(json, context) {
   let { term } = json;
 
@@ -42,7 +44,7 @@ export function metaTypeFromJSON(json, context) {
     const { name } = json,
           metaTypeName = name;  ///
 
-    metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
+    metaType = findMetaTypeByMetaTypeName(metaTypeName);
   }
 
   return metaType;