occam-verify-cli 1.0.185 → 1.0.198

package/src/node/variable.js

@@ -1,19 +1,26 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class VariableNode extends Node {
+export default class VariableNode extends NonTerminalNode {
   getVariableName() {
-    const variableName = this.fromFirstChildNode((firstChildNode) => {
-      const nameTerminalNode = firstChildNode,  ///
-            content = nameTerminalNode.getContent(),
-            variableName = content; ///
+    let variableName;
 
-      return variableName;
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
+
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
+              content = terminalNode.getContent();
+
+        variableName = content; ///
+
+        return true;
+      }
     });
 
     return variableName;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(VariableNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(VariableNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/nominal/parser.js

@@ -1,9 +1,9 @@
 "use strict";
 
 import { NominalParser as NominalParserBase } from "occam-grammars";
+import { NonTerminalNode as defaultNonTerminalNode } from "occam-parsers";
 
 import NonTerminalNodeMap from "../nonTerminalNodeMap";
-import defaultNonTerminalNode from "../defaultTerminalNode";
 
 export default class NominalParser extends NominalParserBase {
   static NonTerminalNodeMap = NonTerminalNodeMap;

package/src/nonTerminalNodeMap.js

@@ -1,49 +1,59 @@
 "use strict";
 
-import TermNode from "./node/term"
-import TypeNode from "./node/type"
-import RuleNode from "./node/rule"
-import StepNode from "./node/step"
-import ErrorNode from "./node/error"
-import FrameNode from "./node/frame"
-import AxiomNode from "./node/axiom"
-import LabelNode from "./node/label"
-import LemmaNode from "./node/lemma"
-import ProofNode from "./node/proof"
-import PremiseNode from "./node/premise"
-import TheoremNode from "./node/theorem"
-import SubproofNode from "./node/subproof"
-import PropertyNode from "./node/property"
-import MetaTypeNode from "./node/metaType"
-import EqualityNode from "./node/equality"
-import VariableNode from "./node/variable"
-import StatementNode from "./node/statement"
-import ReferenceNode from "./node/reference"
-import DeductionNode from "./node/deduction"
-import JudgementNode from "./node/judgement"
-import MetaLemmaNode from "./node/metaLemma"
-import ParameterNode from "./node/parameter"
-import DerivationNode from "./node/derivation"
-import CombinatorNode from "./node/combinator"
-import ConclusionNode from "./node/conclusion"
-import ConjectureNode from "./node/conjecture"
-import SuppositionNode from "./node/supposition"
-import ConstructorNode from "./node/constructor"
-import DeclarationNode from "./node/declaration"
-import MetatheoremNode from "./node/metatheorem"
-import MetavariableNode from "./node/metavariable"
-import ProcedureCallNode from "./node/procedureCall"
-import SubDerivationNode from "./node/subDerivation"
+import TermNode from "./node/term";
+import RuleNode from "./node/rule";
+import StepNode from "./node/step";
+import TypeNode from "./node/type";
+import TypesNode from "./node/types";
+import ErrorNode from "./node/error";
+import FrameNode from "./node/frame";
+import AxiomNode from "./node/axiom";
+import LemmaNode from "./node/lemma";
+import ProofNode from "./node/proof";
+import LabelNode from "./node/label";
+import LabelsNode from "./node/labels";
+import PremiseNode from "./node/premise";
+import TheoremNode from "./node/theorem";
+import ArgumentNode from "./node/argument";
+import SubproofNode from "./node/subproof";
+import PropertyNode from "./node/property";
+import MetaTypeNode from "./node/metaType";
+import EqualityNode from "./node/equality";
+import VariableNode from "./node/variable";
+import StatementNode from "./node/statement";
+import ReferenceNode from "./node/reference";
+import DeductionNode from "./node/deduction";
+import JudgementNode from "./node/judgement";
+import MetaLemmaNode from "./node/metaLemma";
+import ParameterNode from "./node/parameter";
+import DerivationNode from "./node/derivation";
+import CombinatorNode from "./node/combinator";
+import ConclusionNode from "./node/conclusion";
+import ConjectureNode from "./node/conjecture";
+import SuppositionNode from "./node/supposition";
+import ConstructorNode from "./node/constructor";
+import DeclarationNode from "./node/declaration";
+import MetatheoremNode from "./node/metatheorem";
+import MetaArgumentNode from "./node/metaArgument";
+import MetavariableNode from "./node/metavariable";
+import ProcedureCallNode from "./node/procedureCall";
+import SubDerivationNode from "./node/subDerivation";
 import TypeAssertionNode from "./node/assertion/type";
 import typeDeclarationNode from "./node/declaration/type";
 import PropertyRelationNode from "./node/propertyRelation"
 import DefinedAssertionNode from "./node/assertion/defined";
+import TermSubstitutionNode from "./node/substitution/term";
 import PropertyAssertionNode from "./node/assertion/property";
 import SubproofAssertionNode from "./node/assertion/subproof";
+import FrameSubstitutionNode from "./node/substitution/frame";
+import ParenthesisedLabelNode from "./node/parenthesisedLabel";
 import ContainedAssertionNode from "./node/assertion/contained";
 import SatisfiesAssertionNode from "./node/assertion/satisfies";
+import ParenthesisedLabelsNode from "./node/parenthesisedLabels"
 import PropertyDeclarationNode from "./node/declaration/property";
 import variableDeclarationNode from "./node/declaration/variable";
+import StatementSubstitutionNode from "./node/substitution/statement";
+import ReferenceSubstitutionNode from "./node/substitution/reference";
 import combinatorDeclarationNode from "./node/declaration/combinator";
 import complexTypeDeclarationNode from "./node/declaration/complexType";
 import constructorDeclarationNode from "./node/declaration/constructor";
@@ -53,14 +63,17 @@ import { RULE_RULE_NAME,
          STEP_RULE_NAME,
          TERM_RULE_NAME,
          TYPE_RULE_NAME,
+         TYPES_RULE_NAME,
          PROOF_RULE_NAME,
          ERROR_RULE_NAME,
          FRAME_RULE_NAME,
          AXIOM_RULE_NAME,
-         LABEL_RULE_NAME,
          LEMMA_RULE_NAME,
+         LABEL_RULE_NAME,
+         LABELS_RULE_NAME,
          THEOREM_RULE_NAME,
          PREMISE_RULE_NAME,
+         ARGUMENT_RULE_NAME,
          SUBPROOF_RULE_NAME,
          PROPERTY_RULE_NAME,
          EQUALITY_RULE_NAME,
@@ -81,18 +94,25 @@ import { RULE_RULE_NAME,
          SUPPOSITION_RULE_NAME,
          METATHEOREM_RULE_NAME,
          METAVARIABLE_RULE_NAME,
+         META_ARGUMENT_RULE_NAME,
          SUB_DERIVATION_RULE_NAME,
          TYPE_ASSERTION_RULE_NAME,
          PROCEDURE_CALL_RULE_NAME,
          TYPE_DECLARATION_RULE_NAME,
          PROPERTY_RELATION_RULE_NAME,
          DEFINED_ASSERTION_RULE_NAME,
+         TERM_SUBSTITUTION_RULE_NAME,
          SUBPROOF_ASSERTION_RULE_NAME,
          PROPERTY_ASSERTION_RULE_NAME,
+         FRAME_SUBSTITUTION_RULE_NAME,
          CONTAINED_ASSERTION_RULE_NAME,
          SATISFIES_ASSERTION_RULE_NAME,
+         PARENTHESISED_LABEL_RULE_NAME,
+         PARENTHESISED_LABELS_RULE_NAME,
          PROPERTY_DECLARATION_RULE_NAME,
          VARIABLE_DECLARATION_RULE_NAME,
+         STATEMENT_SUBSTITUTION_RULE_NAME,
+         REFERENCE_SUBSTITUTION_RULE_NAME,
          COMBINATOR_DECLARATION_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME,
          COMPLEX_TYPE_DECLARATION_RULE_NAME,
@@ -103,14 +123,17 @@ const nonTerminalNodeMap = {
   [STEP_RULE_NAME]: StepNode,
   [TERM_RULE_NAME]: TermNode,
   [TYPE_RULE_NAME]: TypeNode,
+  [TYPES_RULE_NAME]: TypesNode,
   [ERROR_RULE_NAME]: ErrorNode,
   [FRAME_RULE_NAME]: FrameNode,
-  [LABEL_RULE_NAME]: LabelNode,
   [LEMMA_RULE_NAME]: LemmaNode,
   [AXIOM_RULE_NAME]: AxiomNode,
   [PROOF_RULE_NAME]: ProofNode,
+  [LABEL_RULE_NAME]: LabelNode,
+  [LABELS_RULE_NAME]: LabelsNode,
   [THEOREM_RULE_NAME]: TheoremNode,
   [PREMISE_RULE_NAME]: PremiseNode,
+  [ARGUMENT_RULE_NAME]: ArgumentNode,
   [PROPERTY_RULE_NAME]: PropertyNode,
   [SUBPROOF_RULE_NAME]: SubproofNode,
   [EQUALITY_RULE_NAME]: EqualityNode,
@@ -121,28 +144,35 @@ const nonTerminalNodeMap = {
   [DEDUCTION_RULE_NAME]: DeductionNode,
   [PARAMETER_RULE_NAME]: ParameterNode,
   [STATEMENT_RULE_NAME]: StatementNode,
+  [META_LEMMA_RULE_NAME]: MetaLemmaNode,
   [COMBINATOR_RULE_NAME]: CombinatorNode,
   [CONCLUSION_RULE_NAME]: ConclusionNode,
   [CONJECTURE_RULE_NAME]: ConjectureNode,
   [DERIVATION_RULE_NAME]: DerivationNode,
-  [META_LEMMA_RULE_NAME]: MetaLemmaNode,
   [SUPPOSITION_RULE_NAME]: SuppositionNode,
   [CONSTRUCTOR_RULE_NAME]: ConstructorNode,
   [DECLARATION_RULE_NAME]: DeclarationNode,
   [METATHEOREM_RULE_NAME]: MetatheoremNode,
   [METAVARIABLE_RULE_NAME]: MetavariableNode,
+  [META_ARGUMENT_RULE_NAME]: MetaArgumentNode,
   [TYPE_ASSERTION_RULE_NAME]: TypeAssertionNode,
   [PROCEDURE_CALL_RULE_NAME]: ProcedureCallNode,
   [SUB_DERIVATION_RULE_NAME]: SubDerivationNode,
   [TYPE_DECLARATION_RULE_NAME]: typeDeclarationNode,
   [PROPERTY_RELATION_RULE_NAME]: PropertyRelationNode,
   [DEFINED_ASSERTION_RULE_NAME]: DefinedAssertionNode,
+  [TERM_SUBSTITUTION_RULE_NAME]: TermSubstitutionNode,
   [SUBPROOF_ASSERTION_RULE_NAME]: SubproofAssertionNode,
   [PROPERTY_ASSERTION_RULE_NAME]: PropertyAssertionNode,
+  [FRAME_SUBSTITUTION_RULE_NAME]: FrameSubstitutionNode,
+  [PARENTHESISED_LABEL_RULE_NAME]: ParenthesisedLabelNode,
   [SATISFIES_ASSERTION_RULE_NAME]: SatisfiesAssertionNode,
   [CONTAINED_ASSERTION_RULE_NAME]: ContainedAssertionNode,
+  [PARENTHESISED_LABELS_RULE_NAME]: ParenthesisedLabelsNode,
   [VARIABLE_DECLARATION_RULE_NAME]: variableDeclarationNode,
   [PROPERTY_DECLARATION_RULE_NAME]: PropertyDeclarationNode,
+  [STATEMENT_SUBSTITUTION_RULE_NAME]: StatementSubstitutionNode,
+  [REFERENCE_SUBSTITUTION_RULE_NAME]: ReferenceSubstitutionNode,
   [COMBINATOR_DECLARATION_RULE_NAME]: combinatorDeclarationNode,
   [CONSTRUCTOR_DECLARATION_RULE_NAME]: constructorDeclarationNode,
   [COMPLEX_TYPE_DECLARATION_RULE_NAME]: complexTypeDeclarationNode,

package/src/ruleNames.js

@@ -4,14 +4,17 @@ export const RULE_RULE_NAME = "rule";
 export const STEP_RULE_NAME = "step";
 export const TERM_RULE_NAME = "term";
 export const TYPE_RULE_NAME = "type";
-export const LABEL_RULE_NAME = "label";
+export const TYPES_RULE_NAME = "types";
 export const LEMMA_RULE_NAME = "lemma";
 export const AXIOM_RULE_NAME = "axiom";
 export const ERROR_RULE_NAME = "error";
 export const FRAME_RULE_NAME = "frame";
 export const PROOF_RULE_NAME = "proof";
+export const LABEL_RULE_NAME = "label";
+export const LABELS_RULE_NAME = "labels";
 export const THEOREM_RULE_NAME = "theorem";
 export const PREMISE_RULE_NAME = "premise";
+export const ARGUMENT_RULE_NAME = "argument";
 export const PROPERTY_RULE_NAME = "property";
 export const EQUALITY_RULE_NAME = "equality";
 export const VARIABLE_RULE_NAME = "variable";
@@ -32,18 +35,25 @@ export const CONSTRUCTOR_RULE_NAME = "constructor";
 export const DECLARATION_RULE_NAME = "declaration";
 export const METATHEOREM_RULE_NAME = "metatheorem";
 export const METAVARIABLE_RULE_NAME = "metavariable";
+export const META_ARGUMENT_RULE_NAME = "metaArgument";
 export const PROCEDURE_CALL_RULE_NAME = "procedureCall";
 export const SUB_DERIVATION_RULE_NAME = "subDerivation";
 export const TYPE_ASSERTION_RULE_NAME = "typeAssertion";
 export const TYPE_DECLARATION_RULE_NAME = "typeDeclaration";
 export const PROPERTY_RELATION_RULE_NAME = "propertyRelation";
 export const DEFINED_ASSERTION_RULE_NAME = "definedAssertion";
+export const TERM_SUBSTITUTION_RULE_NAME = "termSubstitution";
 export const PROPERTY_ASSERTION_RULE_NAME = "propertyAssertion";
 export const SUBPROOF_ASSERTION_RULE_NAME = "subproofAssertion";
+export const FRAME_SUBSTITUTION_RULE_NAME = "frameSubstitution";
 export const CONTAINED_ASSERTION_RULE_NAME = "containedAssertion";
 export const SATISFIES_ASSERTION_RULE_NAME = "satisfiesAssertion";
+export const PARENTHESISED_LABEL_RULE_NAME = "parenthesisedLabel";
+export const PARENTHESISED_LABELS_RULE_NAME = "parenthesisedLabels";
 export const PROPERTY_DECLARATION_RULE_NAME = "propertyDeclaration";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
+export const STATEMENT_SUBSTITUTION_RULE_NAME = "statementSubstitution";
+export const REFERENCE_SUBSTITUTION_RULE_NAME = "referenceSubstitution";
 export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
 export const COMPLEX_TYPE_DECLARATION_RULE_NAME = "complexTypeDeclaration";

package/src/substitution/frame.js

@@ -4,12 +4,6 @@ import dom from "../dom";
 import Substitution from "../substitution";
 import FrameSubstitutionPartialContext from "../context/partial/substitution/frame";
 
-import { nodeQuery } from "../utilities/query";
-
-const frameNodeQuery = nodeQuery("/frameSubstitution/frame[0]"),
-      metavariableNodeQuery = nodeQuery("/frameSubstitution/frame[1]/metavariable!"),
-      frameSubstitutionNodeQuery = nodeQuery("/statement/frameSubstitution");
-
 export default class FrameSubstitution extends Substitution {
   constructor(string, node, tokens, frame, metavariable) {
     super(string, node, tokens);
@@ -42,14 +36,17 @@ export default class FrameSubstitution extends Substitution {
   static fromStatementNode(statementNode, context) {
     let frameSubstitution = null;
 
-    const frameSubstitutionNode = frameSubstitutionNodeQuery(statementNode);
+    const frameSubstitutionNode = statementNode.getFrameSubstitutionNode();
 
     if (frameSubstitutionNode !== null) {
-      const frameNode = frameNodeQuery(frameSubstitutionNode),
-            metavariableNode = metavariableNodeQuery(frameSubstitutionNode);
+      const lastFrameNode = frameSubstitutionNode.getLastFrameNode(),
+            firstFrameNode = frameSubstitutionNode.getFirstFrameNode(),
+            singularMetavariableNode = lastFrameNode.getSingularMetavariableNode();
 
-      if ((frameNode !== null) && (metavariableNode !== null)) {
+      if (singularMetavariableNode !== null) {
         const { Frame, Metavariable } = dom,
+              frameNode = firstFrameNode, ///
+              metavariableNode = singularMetavariableNode,  ///
               frame = Frame.fromFrameNode(frameNode, context),
               metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
               node = frameSubstitutionNode,  ///

package/src/substitution/reference.js

@@ -4,12 +4,6 @@ import dom from "../dom";
 import Substitution from "../substitution";
 import ReferenceSubstitutionPartialContext from "../context/partial/substitution/reference";
 
-import { nodeQuery } from "../utilities/query";
-
-const referenceNodeQuery = nodeQuery("/referenceSubstitution/reference[0]"),
-      metavariableNodeQuery = nodeQuery("/referenceSubstitution/reference[1]/metavariable!"),
-      referenceSubstitutionNodeQuery = nodeQuery("/statement/referenceSubstitution");
-
 export default class ReferenceSubstitution extends Substitution {
   constructor(string, node, tokens, reference, metavariable) {
     super(string, node, tokens);
@@ -33,14 +27,17 @@ export default class ReferenceSubstitution extends Substitution {
   static fromStatementNode(statementNode, context) {
     let referenceSubstitution = null;
 
-    const referenceSubstitutionNode = referenceSubstitutionNodeQuery(statementNode);
+    const referenceSubstitutionNode = statementNode.getReferenceSubstitutionNode();
 
     if (referenceSubstitutionNode !== null) {
-      const referenceNode = referenceNodeQuery(referenceSubstitutionNode),
-            metavariableNode = metavariableNodeQuery(referenceSubstitutionNode);
+      const lastReferenceNode = referenceSubstitutionNode.getLastReferenceNode(),
+            firstReferenceNode = referenceSubstitutionNode.getFirstReferenceNode(),
+            singularMetavariableNode = lastReferenceNode.getSingularMetavariableNode();
 
-      if ((referenceNode !== null) && (metavariableNode !== null)) {
+      if (singularMetavariableNode !== null) {
         const { Reference, Metavariable } = dom,
+              referenceNode = firstReferenceNode, ///
+              metavariableNode = singularMetavariableNode,  ///
               reference = Reference.fromReferenceNode(referenceNode, context),
               metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
               node = referenceSubstitutionNode,  ///

package/src/substitution/term.js

@@ -4,14 +4,9 @@ import dom from "../dom";
 import Substitution from "../substitution";
 import TermSubstitutionPartialContext from "../context/partial/substitution/term";
 
-import { nodeQuery } from "../utilities/query";
 import { stripBracketsFromTerm } from "../utilities/brackets";
 import { stripBracketsFromTermNode } from "../utilities/brackets";
 
-const termNodeQuery = nodeQuery("/termSubstitution/term[0]"),
-      variableNodeQuery = nodeQuery("/termSubstitution/term[1]/variable!"),
-      termSubstitutionNodeQuery = nodeQuery("/statement/termSubstitution");
-
 export default class TermSubstitution extends Substitution {
   constructor(string, node, tokens, term, variable) {
     super(string, node, tokens);
@@ -68,14 +63,17 @@ export default class TermSubstitution extends Substitution {
   static fromStatementNode(statementNode, context) {
     let termSubstitution = null;
 
-    const termSubstitutionNode = termSubstitutionNodeQuery(statementNode);
+    const termSubstitutionNode = statementNode.getTermSubstitutionNode();
 
     if (termSubstitutionNode !== null) {
-      const termNode = termNodeQuery(termSubstitutionNode),
-            variableNode = variableNodeQuery(termSubstitutionNode);
+      const lastTermNode = termSubstitutionNode.getLastTermNode(),
+            firstTermNode = termSubstitutionNode.getFirstTermNode(),
+            singularVariableNode = lastTermNode.getSingularVariableNode(lastTermNode);
 
-      if ((termNode !== null) && (variableNode !== null)) {
+      if (singularVariableNode !== null) {
         const { Term, Variable } = dom,
+              termNode = firstTermNode, ///
+              variableNode = singularVariableNode,  ///
               term = Term.fromTermNode(termNode, context),
               variable = Variable.fromVariableNode(variableNode, context),
               node = termSubstitutionNode,  ///

package/src/unifier/metaLevel.js

@@ -12,7 +12,6 @@ const termNodeQuery = nodeQuery("/term"),
       statementNodeQuery = nodeQuery("/statement"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
-      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       declarationMetavariableNodeQuery = nodeQuery("/declaration/metavariable!");
 
 class MetaLevelUnifier extends Unifier {
@@ -34,9 +33,9 @@ class MetaLevelUnifier extends Unifier {
         let statementUnified;
 
         const statementNode = generalStatementNode, ///
-              statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
+              singularMetavariableNode = statementNode.getSingularMetavariableNode();
 
-        if (statementMetavariableNode !== null) {
+        if (singularMetavariableNode !== null) {
           const { Metavariable, Statement } = dom; ///
 
           let context,

package/src/utilities/brackets.js

@@ -5,12 +5,8 @@ import LocalContext from "../context/local";
 import combinatorBracketedContext from "../context/bracketed/combinator";
 import constructorBracketedContext from "../context/bracketed/constructor";
 
-import { nodeQuery } from "../utilities/query";
 import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
 
-const bracketedTermChildNodeQuery = nodeQuery("/term/argument/term"),
-      bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument/statement");
-
 export function stripBracketsFromTerm(term, context) {
   const termNode = term.getNode(),
         bracketedTermChildNode = bracketedTermChildNodeFromTermNode(termNode);
@@ -69,7 +65,9 @@ export function bracketedTermChildNodeFromTermNode(termNode) {
         termNodeMatchBracketedTermNode = termNode.match(bracketedTermNode, depth);
 
   if (termNodeMatchBracketedTermNode) {
-    bracketedTermChildNode = bracketedTermChildNodeQuery(termNode);
+    const singularTermNode = termNode.getSingularTermNode();
+
+    bracketedTermChildNode = singularTermNode;  ///
   }
 
   return bracketedTermChildNode;
@@ -83,7 +81,9 @@ export function bracketedStatementChildNodeFromStatementNode(statementNode) {
         statementNodeMatchBracketedStatementNode = statementNode.match(bracketedStatementNode, depth);
 
   if (statementNodeMatchBracketedStatementNode) {
-    bracketedStatementChildNode = bracketedStatementChildNodeQuery(statementNode);
+    const singularStatementNode = statementNode.getSingularStatementNode();
+
+    bracketedStatementChildNode = singularStatementNode;  ///
   }
 
   return bracketedStatementChildNode;
@@ -91,8 +91,8 @@ export function bracketedStatementChildNodeFromStatementNode(statementNode) {
 
 function contextFromStatement(statement, context) {
   const statementTokens = statement.getTokens(),
-    tokens = statementTokens, ///
-    localContext = LocalContext.fromContextAndTokens(context, tokens);
+        tokens = statementTokens, ///
+        localContext = LocalContext.fromContextAndTokens(context, tokens);
 
   context = localContext; ///
 

package/src/utilities/json.js

@@ -160,6 +160,19 @@ export function rulesFromJSON(json, fileContext) {
   return rules;
 }
 
+export function labelFromJSON(json, fileContext) {
+  let { label } = json;
+
+  const { Label } = dom,
+        labelJSON = label;  ///
+
+  json = labelJSON; ///
+
+  label = Label.fromJSON(json, fileContext);
+
+  return label;
+}
+
 export function labelsFromJSON(json, fileContext) {
   let { labels } = json;
 
@@ -425,6 +438,12 @@ export function typeToTypeJSON(type) {
   return typeJSON;
 }
 
+export function labelToLabelJSON(label) {
+  const labelJSON = label.toJSON();
+
+  return labelJSON;
+}
+
 export function metaTypeToMetaTypeJSON(metaType) {
   const metaTypeJSON = (metaType !== null) ?
                          metaType.toJSON() :

package/src/utilities/node.js

@@ -3,15 +3,6 @@
 import dom from "../dom";
 
 import { objectType } from "../dom/type";
-import { TYPE_RULE_NAME, VARIABLE_RULE_NAME, PROPERTY_RULE_NAME, PROPERTY_DECLARATION_RULE_NAME } from "../ruleNames";
-
-export function isNodeTypeNode(node) { return isNodeRuleNode(node, TYPE_RULE_NAME); }
-
-export function isNodeVariableNode(node) { return isNodeRuleNode(node, VARIABLE_RULE_NAME); }
-
-export function isNodePropertyNode(node) { return isNodeRuleNode(node, PROPERTY_RULE_NAME); }
-
-export function isNodePropertyDeclarationNode(node) { return isNodeRuleNode(node, PROPERTY_DECLARATION_RULE_NAME); }
 
 export function typeFromTypeNode(typeNode) {
   let type;
@@ -52,21 +43,3 @@ export function statementFromStatementNode(statementNode, context) {
 
   return statement;
 }
-
-function isNodeRuleNode(node, ruleName) {
-  let nodeRuleNode = false;
-
-  const nodeNonTerminalNode = node.isNonTerminalNode();
-
-  if (nodeNonTerminalNode) {
-    const nonTerminalNode = node, ///
-          nonTerminalNodeRuleName = nonTerminalNode.getRuleName(),
-          nonTerminalNodeRuleNameRuleName = (nonTerminalNodeRuleName === ruleName);
-
-    if (nonTerminalNodeRuleNameRuleName) {
-      nodeRuleNode = true;
-    }
-  }
-
-  return nodeRuleNode;
-}

package/src/utilities/subproof.js

@@ -1,18 +1,34 @@
 "use strict";
 
-import { nodeQuery, nodesQuery } from "./query";
 import { nodeAsString, nodesAsString } from "./string";
 
-const lastStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/step[-1]/statement"),
-      suppositionStatementNodesQuery = nodesQuery("/subproof/supposition/statement");
-
 export function subproofStringFromSubproofNode(subproofNode, fileContext) {
   const tokens = fileContext.getTokens(),
-        suppositionStatementNodes = suppositionStatementNodesQuery(subproofNode),
-        lastStepStatementNode = lastStepStatementNodeQuery(subproofNode),
+        suppositionStatementNodes = suppositionStatementNodesFromSubproofNode(subproofNode),
+        lastStepStatementNode = lastStepStatementNodeFromSubproofNode(subproofNode),
         suppositionStatementsString = nodesAsString(suppositionStatementNodes, tokens),
         lastStepStatementString = nodeAsString(lastStepStatementNode, tokens),
         subproofString = `[${suppositionStatementsString}]...${lastStepStatementString}`;
 
   return subproofString;
 }
+
+function lastStepStatementNodeFromSubproofNode(subproofNode) {
+  const lastStepNode = subproofNode.getLastStepNode(),
+        lastStepNodeStatementNode = lastStepNode.getStatementNode(),
+        lastStepStatementNode = lastStepNodeStatementNode;  ///
+
+  return lastStepStatementNode;
+}
+
+function suppositionStatementNodesFromSubproofNode(subproofNode) {
+  const suppositionNodes = subproofNode.getSuppositionNodes(),
+        suppositionNodeStatementNodes = suppositionNodes.map((suppositionNode) => {
+          const suppositionNodeStatementNode = suppositionNode.getStatementNode();
+
+          return suppositionNodeStatementNode;
+        }),
+        suppositionStatementNodes = suppositionNodeStatementNodes;  ///
+
+  return suppositionStatementNodes;
+}

package/src/utilities/type.js

@@ -2,6 +2,15 @@
 
 import { objectType } from "../dom/type";
 
+export function stringFromTypeNameNameAndSuperTypes(typeName, superTypes) {
+  const superTypesString = superTypesStringFromSuperTypes(superTypes),
+        string = (superTypesString !== null) ?
+                   `${typeName}:${superTypesString}` :
+                     typeName; ///
+
+  return string;
+}
+
 export function superTypesStringFromSuperTypes(superTypes) {
   const superTypesString = superTypes.reduce((superTypesString, superType) => {
     if (superType !== objectType) {

package/src/verifier/topLevel.js

@@ -67,8 +67,7 @@ class TopLevelVerifier extends Verifier {
       nodeQuery: lemmaNodeQuery,
       verify: (lemmaNode, fileContext) => {
         const { Lemma } = dom,
-              node = lemmaNode, ///
-              lemma = Lemma.fromNode(node, fileContext),
+              lemma = Lemma.fromLemmaNode(lemmaNode, fileContext),
               lemmaVerified = lemma.verify();
 
         return lemmaVerified;
@@ -78,8 +77,7 @@ class TopLevelVerifier extends Verifier {
       nodeQuery: theoremNodeQuery,
       verify: (theoremNode, fileContext) => {
         const { Theorem } = dom,
-              node = theoremNode, ///
-              theorem = Theorem.fromNode(node, fileContext),
+              theorem = Theorem.fromTheoremNode(theoremNode, fileContext),
               theoremVerified = theorem.verify();
 
         return theoremVerified;
@@ -89,8 +87,7 @@ class TopLevelVerifier extends Verifier {
       nodeQuery: metaLemmaNodeQuery,
       verify: (metaLemmaNode, fileContext) => {
         const { MetaLemma } = dom,
-              node = metaLemmaNode, ///
-              metaLemma = MetaLemma.fromNode(node, fileContext),
+              metaLemma = MetaLemma.fromMetaLemmaNode(metaLemmaNode, fileContext),
               metaLemmaVerified = metaLemma.verify();
 
         return metaLemmaVerified;
@@ -100,8 +97,7 @@ class TopLevelVerifier extends Verifier {
       nodeQuery: conjectureNodeQuery,
       verify: (conjectureNode, fileContext) => {
         const { Conjecture } = dom,
-              node = conjectureNode,  ///
-              conjecture = Conjecture.fromNode(node, fileContext),
+              conjecture = Conjecture.fromConjectureNode(conjectureNode, fileContext),
               conjectureVerified = conjecture.verify();
 
         return conjectureVerified;
@@ -111,8 +107,7 @@ class TopLevelVerifier extends Verifier {
       nodeQuery: metatheoremNodeQuery,
       verify: (metatheoremNode, fileContext) => {
         const { Metatheorem } = dom,
-              node = metatheoremNode, ///
-              metatheorem = Metatheorem.fromNode(node, fileContext),
+              metatheorem = Metatheorem.fromMetatheoremNode(metatheoremNode, fileContext),
               metatheoremVerified = metatheorem.verify();
 
         return metatheoremVerified;