occam-verify-cli 1.0.185 → 1.0.192

package/src/dom/statement.js

@@ -8,7 +8,6 @@ import StatementPartialContext from "../context/partial/statement";
 
 import { domAssigned } from "../dom";
 import { unifyStatement } from "../utilities/unification";
-import { nodeQuery, nodesQuery } from "../utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 import { statementFromStatementNode } from "../utilities/node";
 import { stripBracketsFromStatementNode } from "../utilities/brackets";
@@ -16,16 +15,6 @@ import { definedAssertionFromStatement, containedAssertionFromStatement, subproo
 
 const { match, backwardsSome } = arrayUtilities;
 
-const stepStatementNodeQuery = nodeQuery("/step/statement"),
-      statementTermNodesQuery = nodesQuery("/statement//term"),
-      statementFrameNodesQuery = nodesQuery("/statement//frame"),
-      premiseStatementNodeQuery = nodeQuery("/premise/statement"),
-      deductionStatementNodeQuery = nodeQuery("/deduction/statement"),
-      conclusionStatementNodeQuery = nodeQuery("/conclusion/statement"),
-      suppositionStatementNodeQuery = nodeQuery("/supposition/statement"),
-      declarationStatementNodeQuery = nodeQuery("/declaration/statement"),
-      containedAssertionStatementNodeQuery = nodeQuery("/containedAssertion/statement");
-
 export default domAssigned(class Statement {
   constructor(string, node, tokens) {
     this.string = string;
@@ -62,12 +51,12 @@ export default domAssigned(class Statement {
 
     const termNode = term.getNode(),
           statementNode = this.node,
-          statementTermNodes = statementTermNodesQuery(statementNode);
+          statementNodeTermNodes = statementNode.getTermNodes();
 
-    termContained = statementTermNodes.some((statementTermNode) => {  ///
-      const termNodeMatchesStatementVariableNode = termNode.match(statementTermNode);
+    termContained = statementNodeTermNodes.some((statementNodeTermNode) => {  ///
+      const termNodeMatchesStatementNodeTermNode = termNode.match(statementNodeTermNode);
 
-      if (termNodeMatchesStatementVariableNode) {
+      if (termNodeMatchesStatementNodeTermNode) {
         return true;
       }
     });
@@ -89,12 +78,12 @@ export default domAssigned(class Statement {
 
     const frameNode = frame.getNode(),
           statementNode = this.node,
-          statementFrameNodes = statementFrameNodesQuery(statementNode);
+          statementNodeFrameNodes = statementNode.getFrameNodes();
 
-    frameContained = statementFrameNodes.some((statementFrameNode) => {  ///
-      const frameNodeMatchesStatementMetavariableNode = frameNode.match(statementFrameNode);
+    frameContained = statementNodeFrameNodes.some((statementNodeFrameNode) => {  ///
+      const frameNodeMatchesStatementNodeFrameNode = frameNode.match(statementNodeFrameNode);
 
-      if (frameNodeMatchesStatementMetavariableNode) {
+      if (frameNodeMatchesStatementNodeFrameNode) {
         return true;
       }
     });
@@ -276,11 +265,9 @@ export default domAssigned(class Statement {
   static fromStepNode(stepNode, fileContext) {
     let statement = null;
 
-    const stepStatementNode = stepStatementNodeQuery(stepNode);
-
-    if (stepStatementNode !== null) {
-      const statementNode = stepStatementNode; ///
+    const statementNode = stepNode.getStatementNode();
 
+    if (statementNode !== null) {
       statement = statementFromStatementNode(statementNode, fileContext);
     }
 
@@ -290,11 +277,10 @@ export default domAssigned(class Statement {
   static fromPremiseNode(premiseNode, fileContext) {
     let statement = null;
 
-    const premiseStatementNode = premiseStatementNodeQuery(premiseNode);
+    const statementNode = premiseNode.getStatementNode();
 
-    if (premiseStatementNode !== null) {
-      const statementNode = premiseStatementNode, ///
-            localContext = LocalContext.fromFileContext(fileContext),
+    if (statementNode !== null) {
+      const localContext = LocalContext.fromFileContext(fileContext),
             context = localContext;  ///
 
       statement = statementFromStatementNode(statementNode, context);
@@ -312,11 +298,10 @@ export default domAssigned(class Statement {
   static fromDeductionNode(deductionNode, fileContext) {
     let statement = null;
 
-    const deductionStatementNode = deductionStatementNodeQuery(deductionNode);
+    const statementNode = deductionNode.getStatementNode();
 
-    if (deductionStatementNode !== null) {
-      const statementNode = deductionStatementNode,  ///
-            localContext = LocalContext.fromFileContext(fileContext),
+    if (statementNode !== null) {
+      const localContext = LocalContext.fromFileContext(fileContext),
             context = localContext;  ///
 
       statement = statementFromStatementNode(statementNode, context);
@@ -328,11 +313,10 @@ export default domAssigned(class Statement {
   static fromConclusionNode(conclusionNode, fileContext) {
     let statement = null;
 
-    const conclusionStatementNode = conclusionStatementNodeQuery(conclusionNode);
+    const statementNode = conclusionNode.getStatementNode();
 
-    if (conclusionStatementNode !== null) {
-      const statementNode = conclusionStatementNode,  ///
-            localContext = LocalContext.fromFileContext(fileContext),
+    if (statementNode !== null) {
+      const localContext = LocalContext.fromFileContext(fileContext),
             context = localContext;  ///
 
       statement = statementFromStatementNode(statementNode, context);
@@ -344,11 +328,10 @@ export default domAssigned(class Statement {
   static fromSuppositionNode(suppositionNode, fileContext) {
     let statement = null;
 
-    const suppositionStatementNode = suppositionStatementNodeQuery(suppositionNode);
+    const statementNode = suppositionNode.getStatementNode();
 
-    if (suppositionStatementNode !== null) {
-      const statementNode = suppositionStatementNode, ///
-            localContext = LocalContext.fromFileContext(fileContext),
+    if (statementNode !== null) {
+      const localContext = LocalContext.fromFileContext(fileContext),
             context = localContext;  ///
 
       statement = statementFromStatementNode(statementNode, context);
@@ -360,9 +343,7 @@ export default domAssigned(class Statement {
   static fromDeclarationNode(declarationNode, fileContext) {
     let statementNode;
 
-    const declarationStatementNode = declarationStatementNodeQuery(declarationNode);
-
-    statementNode = declarationStatementNode; ///
+    statementNode = declarationNode.getStatementNode(); ///
 
     statementNode = stripBracketsFromStatementNode(statementNode);  ///
 
@@ -376,11 +357,10 @@ export default domAssigned(class Statement {
   static fromContainedAssertionNode(containedAssertionNode, fileContext) {
     let statement = null;
 
-    const containedAssertionStatementNode = containedAssertionStatementNodeQuery(containedAssertionNode);
+    const statementNode = containedAssertionNode.getStatementNode();
 
-    if (containedAssertionStatementNode !== null) {
-      const statementNode = containedAssertionStatementNode, ///
-            localContext = LocalContext.fromFileContext(fileContext),
+    if (statementNode !== null) {
+      const localContext = LocalContext.fromFileContext(fileContext),
             context = localContext;  ///
 
       statement = statementFromStatementNode(statementNode, context);

package/src/dom/step.js

@@ -4,12 +4,9 @@ import dom from "../dom";
 import unifyMixins from "../mixins/step/unify";
 import Substitutions from "../substitutions";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { propertyAssertionFromStatement } from "../utilities/context";
 
-const stepNodeQuery = nodeQuery("/step");
-
 export default domAssigned(class Step {
   constructor(string, statement, reference) {
     this.string = string;
@@ -140,10 +137,11 @@ export default domAssigned(class Step {
   static fromStepOrSubproofNode(stepOrSubproofNode, fileContext) {
     let step = null;
 
-    const stepNode = stepNodeQuery(stepOrSubproofNode);
+    const stepNode = stepOrSubproofNode.isStepNode();
 
-    if (stepNode !== null) {
+    if (stepNode) {
       const { Statement, Reference } = dom,
+            stepNode = stepOrSubproofNode,  ///
             node = stepNode, ///
             string = fileContext.nodeAsString(node),
             statement = Statement.fromStepNode(stepNode, fileContext),

package/src/dom/subDerivation.js

@@ -4,14 +4,11 @@ import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
 
-import { nodesQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { assignAssignments } from "../utilities/assignments";
 
 const { last } = arrayUtilities;
 
-const stepOrSubproofNodesQuery = nodesQuery("/subDerivation/step|subproof");
-
 export default domAssigned(class SubDerivation {
   constructor(stepsOrSubproofs) {
     this.stepsOrSubproofs = stepsOrSubproofs;
@@ -65,7 +62,7 @@ export default domAssigned(class SubDerivation {
 
 function stepOrSubproofFromSubDerivationNode(subDerivationNode, fileContext) {
   const { Step, Subproof } = dom,
-        stepOrSubproofNodes = stepOrSubproofNodesQuery(subDerivationNode),
+        stepOrSubproofNodes = subDerivationNode.getStepOrSubproofNodes(),
         stepsOrSubproofs = stepOrSubproofNodes.map((stepOrSubproofNode) => {
           const subproof = Subproof.fromStepOrSubproofNode(stepOrSubproofNode, fileContext),
                 step = Step.fromStepOrSubproofNode(stepOrSubproofNode, fileContext),

package/src/dom/subproof.js

@@ -5,13 +5,8 @@ import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 
 import { domAssigned } from "../dom";
-import { nodeQuery, nodesQuery } from "../utilities/query";
 import { subproofStringFromSubproofNode } from "../utilities/subproof";
 
-const subproofNodeQuery = nodeQuery("/subproof"),
-      suppositionNodesQuery = nodesQuery("/subproof/supposition"),
-      subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
-
 export default domAssigned(class Subproof {
   constructor(string, suppositions, subDerivation) {
     this.string = string;
@@ -120,13 +115,14 @@ export default domAssigned(class Subproof {
   static fromStepOrSubproofNode(sStepOrSubproofNode, fileContext) {
     let subproof = null;
 
-    const subproofNode = subproofNodeQuery(sStepOrSubproofNode);
+    const subproofNode = sStepOrSubproofNode.isSubproofNode();
 
-    if (subproofNode !== null) {
-      const subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
-            string = subproofString,  ///
+    if (subproofNode) {
+      const subproofNode = sStepOrSubproofNode, ///
             suppositions = suppositionsFromSubproofNode(subproofNode, fileContext),
-            subDerivation = subDerivationFromSubproofNode(subproofNode, fileContext);
+            subDerivation = subDerivationFromSubproofNode(subproofNode, fileContext),
+            subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
+            string = subproofString;  ///
 
       subproof = new Subproof(string, suppositions, subDerivation);
     }
@@ -137,7 +133,7 @@ export default domAssigned(class Subproof {
 
 function suppositionsFromSubproofNode(subproofNode, fileContext) {
   const { Supposition } = dom,
-        suppositionNodes = suppositionNodesQuery(subproofNode),
+        suppositionNodes = subproofNode.getSuppositionNodes(),
         suppositions = suppositionNodes.map((suppositionNode) => {
           const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
 
@@ -149,7 +145,7 @@ function suppositionsFromSubproofNode(subproofNode, fileContext) {
 
 function subDerivationFromSubproofNode(subproofNode, fileContext) {
   const { SubDerivation } = dom,
-        subDerivationNode = subDerivationNodeQuery(subproofNode),
+        subDerivationNode = subproofNode.getSubDerivationNode(),
         subDerivation = SubDerivation.fromSubDerivationNode(subDerivationNode, fileContext);
 
   return subDerivation;

package/src/dom/term.js

@@ -6,21 +6,15 @@ import dom from "../dom";
 import LocalContext from "../context/local";
 import verifyMixins from "../mixins/term/verify";
 
+import { nodeQuery } from "../utilities/query"
 import { domAssigned } from "../dom";
 import { termFromTermNode } from "../utilities/node";
-import { nodeQuery, nodesQuery } from "../utilities/query"
 import { termNodeFromTermString } from "../context/partial/term";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 const { filter, compress } = arrayUtilities;
 
-const variableNodesQuery = nodesQuery("//variable"),
-      termVariableNodeQuery = nodeQuery("/term/variable!"),
-      typeAssertionTermNodeQuery = nodeQuery("/typeAssertion/term"),
-      definedAssertionTermNodeQuery = nodeQuery("/definedAssertion/term"),
-      propertyRelationTermNodeQuery = nodeQuery("/propertyRelation/term"),
-      propertyAssertionTermNodeQuery = nodeQuery("/propertyAssertion/term"),
-      containedAssertionTermNodeQuery = nodeQuery("/containedAssertion/term");
+const containedAssertionTermNodeQuery = nodeQuery("/containedAssertion/term");
 
 export default domAssigned(class Term {
   constructor(string, node, type) {
@@ -54,7 +48,8 @@ export default domAssigned(class Term {
   }
 
   getVariables(context) {
-    const variableNodes = variableNodesQuery(this.node),
+    const termNode = this.node,
+          variableNodes = termNode.getVariableNodes(),
           variables = variableNodes.map((variableNode) => {
             const { Variable } = dom,
                   variable = Variable.fromVariableNode(variableNode, context);
@@ -89,8 +84,9 @@ export default domAssigned(class Term {
   }
 
   isSimple() {
-    const termVariableNode = termVariableNodeQuery(this.node),
-          simple = (termVariableNode !== null);
+    const termNode = this.node,
+          singularVariableNode = termNode.getSingularVariableNode(),
+          simple = (singularVariableNode !== null);
 
     return simple;
   }
@@ -209,11 +205,7 @@ export default domAssigned(class Term {
   }
 
   static fromTermNode(termNode, context) {
-    let term = null;
-
-    if (termNode !== null) {
-      term = termFromTermNode(termNode, context);
-    }
+    const term = termFromTermNode(termNode, context);
 
     return term;
   }
@@ -229,11 +221,9 @@ export default domAssigned(class Term {
   static fromTypeAssertionNode(typeAssertionNode, context) {
     let term = null;
 
-    const typeAssertionTermNode = typeAssertionTermNodeQuery(typeAssertionNode);
-
-    if (typeAssertionTermNode !== null) {
-      const termNode = typeAssertionTermNode;  ///
+    const termNode = typeAssertionNode.getTermNode();
 
+    if (termNode !== null) {
       term = termFromTermNode(termNode, context);
     }
 
@@ -243,11 +233,9 @@ export default domAssigned(class Term {
   static fromDefinedAssertionNode(definedAssertionNode, context) {
     let term = null;
 
-    const definedAssertionTermNode = definedAssertionTermNodeQuery(definedAssertionNode);
-
-    if (definedAssertionTermNode !== null) {
-      const termNode = definedAssertionTermNode;  ///
+    const termNode = definedAssertionNode.getTermNode();
 
+    if (termNode !== null) {
       term = termFromTermNode(termNode, context);
     }
 
@@ -255,16 +243,14 @@ export default domAssigned(class Term {
   }
 
   static fromPropertyRelationNode(propertyRelationNode, context) {
-    const propertyRelationTermNode = propertyRelationTermNodeQuery(propertyRelationNode),
-          termNode = propertyRelationTermNode, ///
+    const termNode = propertyRelationNode.getTermNode(),
           term = termFromTermNode(termNode, context);
 
     return term;
   }
 
   static fromPropertyAssertionNode(propertyAssertionNode, context) {
-    const propertyAssertionTermNode = propertyAssertionTermNodeQuery(propertyAssertionNode),
-          termNode = propertyAssertionTermNode,
+    const termNode = propertyAssertionNode.getTermNode(),
           term = termFromTermNode(termNode, context);
 
     return term;
@@ -273,11 +259,9 @@ export default domAssigned(class Term {
   static fromContainedAssertionNode(containedAssertionNode, context) {
     let term = null;
 
-    const containedAssertionTermNode = containedAssertionTermNodeQuery(containedAssertionNode);
-
-    if (containedAssertionTermNode !== null) {
-      const termNode = containedAssertionTermNode;
+    const termNode = containedAssertionNode.getTermNode();
 
+    if (termNode !== null) {
       term = termFromTermNode(termNode, context);
     }
 

package/src/dom/theorem.js

@@ -30,5 +30,10 @@ export default domAssigned(class Theorem extends TopLevelAssertion {
 
   static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Theorem, json, fileContext); }
 
-  static fromNode(node, fileContext) { return TopLevelAssertion.fromNode(Theorem, node, fileContext); }
+  static fromTheoremNode(theoremNode, fileContext) {
+    const node = theoremNode, ///
+          theorem = TopLevelAssertion.fromNode(Theorem, node, fileContext);
+
+    return theorem;
+  }
 });

package/src/dom/topLevelAssertion.js

@@ -6,29 +6,25 @@ import dom from "../dom";
 import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 
-import { nodeQuery, nodesQuery } from "../utilities/query";
 import { labelsFromJSON,
-         labelsToLabelsJSON,
          deductionFromJSON,
+         labelsToLabelsJSON,
+         satisfiableFromJSON,
          suppositionsFromJSON,
          deductionToDeductionJSON,
          suppositionsToSuppositionsJSON } from "../utilities/json";
 
 const { reverse, extract, backwardsEvery } = arrayUtilities;
 
-const proofNodeQuery = nodeQuery("/*/proof"),
-      labelNodesQuery = nodesQuery("/*/parenthesisedLabels/labels/label"),
-      deductionNodeQuery = nodeQuery("/*/deduction"),
-      suppositionNodesQuery = nodesQuery("/*/supposition");
-
 export default class TopLevelAssertion {
-  constructor(fileContext, string, labels, suppositions, deduction, proof) {
+  constructor(fileContext, string, labels, suppositions, deduction, proof, satisfiable) {
     this.fileContext = fileContext;
     this.string = string;
     this.labels = labels;
     this.suppositions = suppositions;
     this.deduction = deduction;
     this.proof = proof;
+    this.satisfiable = satisfiable;
   }
 
   getFileContext() {
@@ -55,6 +51,10 @@ export default class TopLevelAssertion {
     return this.proof;
   }
 
+  isSatisfiable() {
+    return this.satisfiable;
+  }
+
   getStatement() { return this.deduction.getStatement(); }
 
   matchMetavariableName(metavariableName) {
@@ -223,10 +223,12 @@ export default class TopLevelAssertion {
           labels = labelsJSON,  ///
           deduction = deductionJSON,  ///
           suppositions = suppositionsJSON,  ///
+          satisfiable = this.satisfiable,
           json = {
             labels,
             deduction,
-            suppositions
+            suppositions,
+            satisfiable
           };
 
     return json;
@@ -234,38 +236,43 @@ export default class TopLevelAssertion {
 
   static fromJSON(Class, json, fileContext) {
     const labels = labelsFromJSON(json, fileContext),
-          suppositions = suppositionsFromJSON(json, fileContext),
           deduction = deductionFromJSON(json, fileContext),
+          satisfiable = satisfiableFromJSON(json, fileContext),
+          suppositions = suppositionsFromJSON(json, fileContext),
           proof = null,
           string = stringFromLabelsAndDeduction(labels, deduction),
-          topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof);
+          topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, satisfiable);
 
     return topLevelAssertion;
   }
 
   static fromNode(Class, node, fileContext) {
-    const labels = labelsFromNode(node, fileContext),
-          suppositions = suppositionsFromNode(node, fileContext),
-          deduction = deductionFromNode(node, fileContext),
-          proof = proofFromNode(node, fileContext),
+    const topLevelAssertionNode = node, ///
+          satisfiable = topLevelAssertionNode.isSatisfiable(),
+          proofNode = topLevelAssertionNode.getProofNode(),
+          labelNodes = topLevelAssertionNode.getLabelNodes(),
+          deductionNode = topLevelAssertionNode.getDeductionNode(),
+          suppositionNodes = topLevelAssertionNode.getSuppositionNodes(),
+          proof = proofFromProofNode(proofNode, fileContext),
+          labels = labelsFromLabelNodes(labelNodes, fileContext),
+          deduction = deductionFromDeductionNode(deductionNode, fileContext),
+          suppositions = suppositionsFromSuppositionNodes(suppositionNodes, fileContext),
           string = stringFromLabelsAndDeduction(labels, deduction),
-          topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof);
+          topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, satisfiable);
 
     return topLevelAssertion;
   }
 }
 
-export function proofFromNode(node, fileContext) {
+export function proofFromProofNode(proofNode, fileContext) {
   const { Proof } = dom,
-        proofNode = proofNodeQuery(node),
         proof = Proof.fromProofNode(proofNode, fileContext);
 
   return proof;
 }
 
-export function labelsFromNode(node, fileContext) {
+export function labelsFromLabelNodes(labelNodes, fileContext) {
   const { Label } = dom,
-        labelNodes = labelNodesQuery(node),
         labels = labelNodes.map((labelNode) => {
           const label = Label.fromLabelNode(labelNode, fileContext);
 
@@ -275,24 +282,22 @@ export function labelsFromNode(node, fileContext) {
   return labels;
 }
 
-export function deductionFromNode(node, fileContext) {
+export function deductionFromDeductionNode(deductionNode, fileContext) {
   const { Deduction } = dom,
-        deductionNode = deductionNodeQuery(node),
         deduction = Deduction.fromDeductionNode(deductionNode, fileContext);
 
   return deduction;
 }
 
-export function suppositionsFromNode(node, fileContext) {
+export function suppositionsFromSuppositionNodes(suppositionNodes, fileContext) {
   const { Supposition } = dom,
-        suppositionNodes = suppositionNodesQuery(node),
         suppositions = suppositionNodes.map((suppositionNode) => {
           const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
 
           return supposition;
         });
 
-  return suppositions;
+    return suppositions;
 }
 
 export function labelsStringFromLabels(labels) {

package/src/dom/topLevelMetaAssertion.js

@@ -2,13 +2,10 @@
 
 import { arrayUtilities } from "necessary";
 
-import dom from "../dom";
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
-import { nodeQuery } from "../utilities/query";
-import { proofFromNode, deductionFromNode, suppositionsFromNode, stringFromLabelsAndDeduction } from "./topLevelAssertion";
+import { proofFromProofNode, labelsFromLabelNodes, deductionFromDeductionNode, suppositionsFromSuppositionNodes, stringFromLabelsAndDeduction } from "./topLevelAssertion";
 import { labelsFromJSON,
          labelsToLabelsJSON,
          deductionFromJSON,
@@ -20,8 +17,6 @@ import { labelsFromJSON,
 
 const { first } = arrayUtilities;
 
-const labelNodeQuery = nodeQuery("/*/parenthesisedLabel/label");
-
 export default class TopLevelMetaAssertion extends TopLevelAssertion {
   constructor(fileContext, string, labels, suppositions, deduction, proof, substitutions) {
     super(fileContext, string, labels, suppositions, deduction, proof);
@@ -116,36 +111,29 @@ export default class TopLevelMetaAssertion extends TopLevelAssertion {
 
   static fromJSON(Class, json, fileContext) {
     const labels = labelsFromJSON(json, fileContext),
-          substitutions = substitutionsFromJSON(json, fileContext),
-          suppositions = suppositionsFromJSON(json, fileContext),
           deduction = deductionFromJSON(json, fileContext),
+          suppositions = suppositionsFromJSON(json, fileContext),
+          substitutions = substitutionsFromJSON(json, fileContext),
           proof = null,
           string = stringFromLabelsAndDeduction(labels, deduction),
-          topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, substitutions);
+          topLevelMetaAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, substitutions);
 
-    return topLevelAssertion;
+    return topLevelMetaAssertion;
   }
 
   static fromNode(Class, node, fileContext) {
-    const labels = labelsFromNode(node, fileContext),
-          substitutions = Substitutions.fromNothing(),
-          suppositions = suppositionsFromNode(node, fileContext),
-          deduction = deductionFromNode(node, fileContext),
-          proof = proofFromNode(node, fileContext),
+    const topLevelAssertionNode = node, ///
+          proofNode = topLevelAssertionNode.getProofNode(),
+          labelNodes = topLevelAssertionNode.getLabelNodes(),
+          deductionNode = topLevelAssertionNode.getDeductionNode(),
+          suppositionNodes = topLevelAssertionNode.getSuppositionNodes(),
+          proof = proofFromProofNode(proofNode, fileContext),
+          labels = labelsFromLabelNodes(labelNodes, fileContext),
+          deduction = deductionFromDeductionNode(deductionNode, fileContext),
+          suppositions = suppositionsFromSuppositionNodes(suppositionNodes, fileContext),
           string = stringFromLabelsAndDeduction(labels, deduction),
-          metaLemma = new Class(fileContext, string, labels, suppositions, deduction, proof, substitutions);
+          topLevelMetaAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof);
 
-    return metaLemma;
+    return topLevelMetaAssertion;
   }
 }
-
-function labelsFromNode(node, fileContext) {
-  const { Label } = dom,
-        labelNode = labelNodeQuery(node),
-        label = Label.fromLabelNode(labelNode, fileContext),
-        labels = [
-          label
-        ];
-
-  return labels;
-}