occam-verify-cli 1.0.185 → 1.0.192

package/src/node/term.js

@@ -1,7 +1,66 @@
 "use strict";
 
-import Node from "../node";
+import { arrayUtilities } from "necessary";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class TermNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(TermNode, ruleName, childNodes, opacity, precedence); }
+import { isNodeTermNode, isNodeVariableNode } from "../utilities/node";
+
+const { first } = arrayUtilities;
+
+export default class TermNode extends NonTerminalNode {
+  getVariableNodes() {
+    const variableNodes = this.filterDescendantNode((descendantNode) => {
+      const descendantNodeVariableNode = isNodeVariableNode(descendantNode);
+
+      if (descendantNodeVariableNode) {
+        return true;
+      }
+    });
+
+    return variableNodes;
+  }
+
+  getSingularTermNode() {
+    let singularTermNode = null;
+
+    const termNodes = this.filterChildNode((childNode) => {
+            const childNodeTermNode = isNodeTermNode(childNode);
+
+            if (!childNodeTermNode) {
+              return true;
+            }
+          }),
+          termNodesLength = termNodes.length;
+
+    if (termNodesLength === 1) {
+      const firstTermNode = first(termNodes);
+
+      singularTermNode = firstTermNode; ///
+    }
+
+    return singularTermNode;
+  }
+
+  getSingularVariableNode() {
+    let singularVariableNode = null;
+
+    const variableNodes = this.filterChildNode((childNode) => {
+            const childNodeVariableNode = isNodeVariableNode(childNode);
+
+            if (!childNodeVariableNode) {
+              return true;
+            }
+          }),
+          variableNodesLength = variableNodes.length;
+
+    if (variableNodesLength === 1) {
+      const firstVariableNode = first(variableNodes);
+
+      singularVariableNode = firstVariableNode; ///
+    }
+
+    return singularVariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TermNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/theorem.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import TopLevelAssertionNode from "../node/topLevelAssertion";
 
-export default class TheoremNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(TheoremNode, ruleName, childNodes, opacity, precedence); }
+export default class TheoremNode extends TopLevelAssertionNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(TheoremNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/topLevelAssertion.js

@@ -1,7 +1,93 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-export default class TopLevelAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(TopLevelAssertionNode, ruleName, childNodes, opacity, precedence); }
+import { SATISFIABLE } from "../constants";
+import { isNodeProofNode,
+         isNodeDeductionNode,
+         isNodeSuppositionNode,
+         isNodeParenthesisedLabelsNode } from "../utilities/node";
+
+export default class TopLevelAssertionNode extends NonTerminalNode {
+  isSatisfiable() {
+    let satisfiable = false;
+
+    this.someChildNode((childNode, index) => {
+      const terminalNode = childNode,
+            content = terminalNode.getContent(),
+            contentSatisfiable = (content === SATISFIABLE);
+
+      if (contentSatisfiable) {
+        satisfiable = true;
+      }
+
+      if (index === 0) {
+        return true;
+      }
+    });
+
+    return satisfiable;
+  }
+
+  getLabelNodes() {
+    let labelNodes = [];
+
+    const parenthesisedLabelsNode = this.getParenthesisedLabelsNode();
+
+    if (parenthesisedLabelsNode !== null) {
+      labelNodes = parenthesisedLabelsNode.getLabelNodes();
+    }
+
+    return labelNodes;
+  }
+
+  getProofNode() {
+    const proofNode = this.findChildNode((childNode) => {
+      const childNOdeProofNode = isNodeProofNode(childNode);
+
+      if (childNOdeProofNode) {
+        return true;
+      }
+    }) || null;
+
+    return proofNode;
+  }
+
+  getDeductionNode() {
+    const deductionNode = this.findChildNode((childNode) => {
+      const childNOdeDeductionNode = isNodeDeductionNode(childNode);
+
+      if (childNOdeDeductionNode) {
+        return true;
+      }
+    }) || null;
+
+    return deductionNode;
+  }
+
+  getSuppositionNodes() {
+    const suppositionNodes = this.filterChildNode((childNode) => {
+      const childNodeSuppositionNode = isNodeSuppositionNode(childNode);
+
+      if (childNodeSuppositionNode) {
+        return true;
+      }
+    });
+
+    return suppositionNodes;
+  }
+
+  getParenthesisedLabelsNode() {
+    const parenthesisedLabelsNode = this.findChildNode((childNode) => {
+      const childNodeParenthesisedLabelNode = isNodeParenthesisedLabelsNode(childNode);
+
+      if (childNodeParenthesisedLabelNode) {
+        return true;
+      }
+    }) || null;
+
+    return parenthesisedLabelsNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/topLevelMetaAssertion.js

@@ -1,7 +1,63 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
+import { isNodeProofNode, isNodePremiseNode, isNodeConclusionNode, isNodeParenthesisedLabelsNode } from "../utilities/node";
 
-export default class TopLevelMetaAssertionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(TopLevelMetaAssertionNode, ruleName, childNodes, opacity, precedence); }
+export default class TopLevelMetaAssertionNode extends NonTerminalNode {
+  getLabelNodes() {
+    const parenthesisedLabelsNode = this.getParenthesisedLabelsNode(),
+          labelNodes = parenthesisedLabelsNode.getLabelNodes();
+
+    return labelNodes;
+  }
+
+  getProofNode() {
+    const proofNode = this.findChildNode((childNode) => {
+      const childNOdeProofNode = isNodeProofNode(childNode);
+
+      if (childNOdeProofNode) {
+        return true;
+      }
+    }) || null;
+
+    return proofNode;
+  }
+
+  getPremiseNodes() {
+    const premiseNodes = this.filterChildNode((childNode) => {
+      const childNOdePremiseNode = isNodePremiseNode(childNode);
+
+      if (childNOdePremiseNode) {
+        return true;
+      }
+    }) || null;
+
+    return premiseNodes;
+  }
+
+  getConclusionNode() {
+    const conclusionNode = this.findChildNode((childNode) => {
+      const childNOdeConclusionNode = isNodeConclusionNode(childNode);
+
+      if (childNOdeConclusionNode) {
+        return true;
+      }
+    }) || null;
+
+    return conclusionNode;
+  }
+
+  getParenthesisedLabelsNode() {
+    const parenthesisedLabelsNode = this.findChildNode((childNode) => {
+      const childNodeParenthesisedLabelNode = isNodeParenthesisedLabelsNode(childNode);
+
+      if (childNodeParenthesisedLabelNode) {
+        return true;
+      }
+    }) || null;
+
+    return parenthesisedLabelsNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/type.js

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

package/src/node/variable.js

@@ -1,19 +1,26 @@
 "use strict";
 
-import Node from "../node";
+import { NonTerminalNode } from "occam-parsers";
 
-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

@@ -7,9 +7,10 @@ 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 LabelNode from "./node/label"
+import LabelsNode from "./node/labels"
 import PremiseNode from "./node/premise"
 import TheoremNode from "./node/theorem"
 import SubproofNode from "./node/subproof"
@@ -42,6 +43,7 @@ import PropertyAssertionNode from "./node/assertion/property";
 import SubproofAssertionNode from "./node/assertion/subproof";
 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 combinatorDeclarationNode from "./node/declaration/combinator";
@@ -57,8 +59,9 @@ import { RULE_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,
          SUBPROOF_RULE_NAME,
@@ -91,6 +94,7 @@ import { RULE_RULE_NAME,
          PROPERTY_ASSERTION_RULE_NAME,
          CONTAINED_ASSERTION_RULE_NAME,
          SATISFIES_ASSERTION_RULE_NAME,
+         PARENTHESISED_LABELS_RULE_NAME,
          PROPERTY_DECLARATION_RULE_NAME,
          VARIABLE_DECLARATION_RULE_NAME,
          COMBINATOR_DECLARATION_RULE_NAME,
@@ -105,10 +109,11 @@ const nonTerminalNodeMap = {
   [TYPE_RULE_NAME]: TypeNode,
   [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,
   [PROPERTY_RULE_NAME]: PropertyNode,
@@ -141,6 +146,7 @@ const nonTerminalNodeMap = {
   [PROPERTY_ASSERTION_RULE_NAME]: PropertyAssertionNode,
   [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,
   [COMBINATOR_DECLARATION_RULE_NAME]: combinatorDeclarationNode,

package/src/ruleNames.js

@@ -4,12 +4,13 @@ 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 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 PROPERTY_RULE_NAME = "property";
@@ -42,6 +43,7 @@ export const PROPERTY_ASSERTION_RULE_NAME = "propertyAssertion";
 export const SUBPROOF_ASSERTION_RULE_NAME = "subproofAssertion";
 export const CONTAINED_ASSERTION_RULE_NAME = "containedAssertion";
 export const SATISFIES_ASSERTION_RULE_NAME = "satisfiesAssertion";
+export const PARENTHESISED_LABELS_RULE_NAME = "parenthesisedLabels";
 export const PROPERTY_DECLARATION_RULE_NAME = "propertyDeclaration";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
 export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";

package/src/utilities/node.js

@@ -3,15 +3,156 @@
 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";
+import { RULE_RULE_NAME,
+         STEP_RULE_NAME,
+         TERM_RULE_NAME,
+         TYPE_RULE_NAME,
+         LEMMA_RULE_NAME,
+         AXIOM_RULE_NAME,
+         ERROR_RULE_NAME,
+         FRAME_RULE_NAME,
+         PROOF_RULE_NAME,
+         LABEL_RULE_NAME,
+         LABELS_RULE_NAME,
+         THEOREM_RULE_NAME,
+         PREMISE_RULE_NAME,
+         PROPERTY_RULE_NAME,
+         EQUALITY_RULE_NAME,
+         VARIABLE_RULE_NAME,
+         SUBPROOF_RULE_NAME,
+         META_TYPE_RULE_NAME,
+         PARAMETER_RULE_NAME,
+         DEDUCTION_RULE_NAME,
+         JUDGEMENT_RULE_NAME,
+         REFERENCE_RULE_NAME,
+         STATEMENT_RULE_NAME,
+         META_LEMMA_RULE_NAME,
+         COMBINATOR_RULE_NAME,
+         CONCLUSION_RULE_NAME,
+         CONJECTURE_RULE_NAME,
+         DERIVATION_RULE_NAME,
+         SUPPOSITION_RULE_NAME,
+         CONSTRUCTOR_RULE_NAME,
+         DECLARATION_RULE_NAME,
+         METATHEOREM_RULE_NAME,
+         METAVARIABLE_RULE_NAME,
+         PROCEDURE_CALL_RULE_NAME,
+         SUB_DERIVATION_RULE_NAME,
+         TYPE_ASSERTION_RULE_NAME,
+         TYPE_DECLARATION_RULE_NAME,
+         PROPERTY_RELATION_RULE_NAME,
+         DEFINED_ASSERTION_RULE_NAME,
+         PROPERTY_ASSERTION_RULE_NAME,
+         SUBPROOF_ASSERTION_RULE_NAME,
+         CONTAINED_ASSERTION_RULE_NAME,
+         SATISFIES_ASSERTION_RULE_NAME,
+         PROPERTY_DECLARATION_RULE_NAME,
+         VARIABLE_DECLARATION_RULE_NAME,
+         PARENTHESISED_LABELS_RULE_NAME,
+         COMBINATOR_DECLARATION_RULE_NAME,
+         CONSTRUCTOR_DECLARATION_RULE_NAME,
+         COMPLEX_TYPE_DECLARATION_RULE_NAME,
+         METAVARIABLE_DECLARATION_RULE_NAME } from "../ruleNames";
 
-export function isNodeTypeNode(node) { return isNodeRuleNode(node, TYPE_RULE_NAME); }
+export function isNodeRuleNode(node) { return isNodeRuleNodeByRuleName(node, RULE_RULE_NAME); }
 
-export function isNodeVariableNode(node) { return isNodeRuleNode(node, VARIABLE_RULE_NAME); }
+export function isNodeStepNode(node) { return isNodeRuleNodeByRuleName(node, STEP_RULE_NAME); }
 
-export function isNodePropertyNode(node) { return isNodeRuleNode(node, PROPERTY_RULE_NAME); }
+export function isNodeTermNode(node) { return isNodeRuleNodeByRuleName(node, TERM_RULE_NAME); }
 
-export function isNodePropertyDeclarationNode(node) { return isNodeRuleNode(node, PROPERTY_DECLARATION_RULE_NAME); }
+export function isNodeTypeNode(node) { return isNodeRuleNodeByRuleName(node, TYPE_RULE_NAME); }
+
+export function isNodeLemmaNode(node) { return isNodeRuleNodeByRuleName(node, LEMMA_RULE_NAME); }
+
+export function isNodeAxiomNode(node) { return isNodeRuleNodeByRuleName(node, AXIOM_RULE_NAME); }
+
+export function isNodeErrorNode(node) { return isNodeRuleNodeByRuleName(node, ERROR_RULE_NAME); }
+
+export function isNodeFrameNode(node) { return isNodeRuleNodeByRuleName(node, FRAME_RULE_NAME); }
+
+export function isNodeProofNode(node) { return isNodeRuleNodeByRuleName(node, PROOF_RULE_NAME); }
+
+export function isNodeLabelNode(node) { return isNodeRuleNodeByRuleName(node, LABEL_RULE_NAME); }
+
+export function isNodeLabelsNode(node) { return isNodeRuleNodeByRuleName(node, LABELS_RULE_NAME); }
+
+export function isNodeTheoremNode(node) { return isNodeRuleNodeByRuleName(node, THEOREM_RULE_NAME); }
+
+export function isNodePremiseNode(node) { return isNodeRuleNodeByRuleName(node, PREMISE_RULE_NAME); }
+
+export function isNodePropertyNode(node) { return isNodeRuleNodeByRuleName(node, PROPERTY_RULE_NAME); }
+
+export function isNodeEqualityNode(node) { return isNodeRuleNodeByRuleName(node, EQUALITY_RULE_NAME); }
+
+export function isNodeVariableNode(node) { return isNodeRuleNodeByRuleName(node, VARIABLE_RULE_NAME); }
+
+export function isNodeSubproofNode(node) { return isNodeRuleNodeByRuleName(node, SUBPROOF_RULE_NAME); }
+
+export function isNodeMetaTypeNode(node) { return isNodeRuleNodeByRuleName(node, META_TYPE_RULE_NAME); }
+
+export function isNodeParameterNode(node) { return isNodeRuleNodeByRuleName(node, PARAMETER_RULE_NAME); }
+
+export function isNodeDeductionNode(node) { return isNodeRuleNodeByRuleName(node, DEDUCTION_RULE_NAME); }
+
+export function isNodeJudgementNode(node) { return isNodeRuleNodeByRuleName(node, JUDGEMENT_RULE_NAME); }
+
+export function isNodeReferenceNode(node) { return isNodeRuleNodeByRuleName(node, REFERENCE_RULE_NAME); }
+
+export function isNodeStatementNode(node) { return isNodeRuleNodeByRuleName(node, STATEMENT_RULE_NAME); }
+
+export function isNodeMetaLemmaNode(node) { return isNodeRuleNodeByRuleName(node, META_LEMMA_RULE_NAME); }
+
+export function isNodeCombinatorNode(node) { return isNodeRuleNodeByRuleName(node, COMBINATOR_RULE_NAME); }
+
+export function isNodeConclusionNode(node) { return isNodeRuleNodeByRuleName(node, CONCLUSION_RULE_NAME); }
+
+export function isNodeConjectureNode(node) { return isNodeRuleNodeByRuleName(node, CONJECTURE_RULE_NAME); }
+
+export function isNodeDerivationNode(node) { return isNodeRuleNodeByRuleName(node, DERIVATION_RULE_NAME); }
+
+export function isNodeSuppositionNode(node) { return isNodeRuleNodeByRuleName(node, SUPPOSITION_RULE_NAME); }
+
+export function isNodeConstructorNode(node) { return isNodeRuleNodeByRuleName(node, CONSTRUCTOR_RULE_NAME); }
+
+export function isNodeDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, DECLARATION_RULE_NAME); }
+
+export function isNodeMetatheoremNode(node) { return isNodeRuleNodeByRuleName(node, METATHEOREM_RULE_NAME); }
+
+export function isNodeMetavariableNode(node) { return isNodeRuleNodeByRuleName(node, METAVARIABLE_RULE_NAME); }
+
+export function isNodeProcedureCallNode(node) { return isNodeRuleNodeByRuleName(node, PROCEDURE_CALL_RULE_NAME); }
+
+export function isNodeSubDerivationNode(node) { return isNodeRuleNodeByRuleName(node, SUB_DERIVATION_RULE_NAME); }
+
+export function isNodeTypeAssertionNode(node) { return isNodeRuleNodeByRuleName(node, TYPE_ASSERTION_RULE_NAME); }
+
+export function isNodeTypeDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, TYPE_DECLARATION_RULE_NAME); }
+
+export function isNodePropertyRelationNode(node) { return isNodeRuleNodeByRuleName(node, PROPERTY_RELATION_RULE_NAME); }
+
+export function isNodeDefinedAssertionNode(node) { return isNodeRuleNodeByRuleName(node, DEFINED_ASSERTION_RULE_NAME); }
+
+export function isNodePropertyAssertionNode(node) { return isNodeRuleNodeByRuleName(node, PROPERTY_ASSERTION_RULE_NAME); }
+
+export function isNodeSubproofAssertionNode(node) { return isNodeRuleNodeByRuleName(node, SUBPROOF_ASSERTION_RULE_NAME); }
+
+export function isNodeContainedAssertionNode(node) { return isNodeRuleNodeByRuleName(node, CONTAINED_ASSERTION_RULE_NAME); }
+
+export function isNodeSatisfiesAssertionNode(node) { return isNodeRuleNodeByRuleName(node, SATISFIES_ASSERTION_RULE_NAME); }
+
+export function isNodePropertyDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, PROPERTY_DECLARATION_RULE_NAME); }
+
+export function isNodeVariableDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, VARIABLE_DECLARATION_RULE_NAME); }
+
+export function isNodeParenthesisedLabelsNode(node) { return isNodeRuleNodeByRuleName(node, PARENTHESISED_LABELS_RULE_NAME); }
+
+export function isNodeCombinatorDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, COMBINATOR_DECLARATION_RULE_NAME); }
+
+export function isNodeConstructorDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, CONSTRUCTOR_DECLARATION_RULE_NAME); }
+
+export function isNodeComplexTypeDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, COMPLEX_TYPE_DECLARATION_RULE_NAME); }
+
+export function isNodeMetavariableDeclarationNode(node) { return isNodeRuleNodeByRuleName(node, METAVARIABLE_DECLARATION_RULE_NAME); }
 
 export function typeFromTypeNode(typeNode) {
   let type;
@@ -53,7 +194,7 @@ export function statementFromStatementNode(statementNode, context) {
   return statement;
 }
 
-function isNodeRuleNode(node, ruleName) {
+function isNodeRuleNodeByRuleName(node, ruleName) {
   let nodeRuleNode = false;
 
   const nodeNonTerminalNode = node.isNonTerminalNode();

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;

package/lib/defaultTerminalNode.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _Node = /*#__PURE__*/ _interop_require_default(require("./Node"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var defaultNonTerminalNode = _Node.default; ///
-var _default = defaultNonTerminalNode;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9kZWZhdWx0VGVybWluYWxOb2RlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbIlwidXNlIHN0cmljdFwiO1xuXG5pbXBvcnQgTm9kZSBmcm9tIFwiLi9Ob2RlXCI7XG5cbmNvbnN0IGRlZmF1bHROb25UZXJtaW5hbE5vZGUgPSBOb2RlOyAgLy8vXG5cbmV4cG9ydCBkZWZhdWx0IGRlZmF1bHROb25UZXJtaW5hbE5vZGU7XG4iXSwibmFtZXMiOlsiZGVmYXVsdE5vblRlcm1pbmFsTm9kZSIsIk5vZGUiXSwibWFwcGluZ3MiOiJBQUFBOzs7OytCQU1BOzs7ZUFBQTs7OzJEQUppQjs7Ozs7O0FBRWpCLElBQU1BLHlCQUF5QkMsYUFBSSxFQUFHLEdBQUc7SUFFekMsV0FBZUQifQ==