occam-verify-cli 1.0.251 → 1.0.252

package/src/node/lemma.js

@@ -1,7 +1,51 @@
 "use strict";
 
-import TopLevelAssertionNode from "../node/topLevelAssertion";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class LemmaNode extends TopLevelAssertionNode {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(LemmaNode, ruleName, childNodes, opacity, precedence); }
+import { LEMMA_BODY_RULE_NAME, LEMMA_HEADER_RULE_NAME } from "../ruleNames";
+
+export default class LemmaNode extends NonTerminalNode {
+  getLemmaBodyNode() {
+    const ruleName = LEMMA_BODY_RULE_NAME,
+          lemmaBodyNode = this.getNodeByRuleName(ruleName);
+
+    return lemmaBodyNode;
+  }
+
+  getLemmaHeaderNode() {
+    const ruleName = LEMMA_HEADER_RULE_NAME,
+          lemmaHeaderNode = this.getNodeByRuleName(ruleName);
+
+    return lemmaHeaderNode;
+  }
+
+  getLabelNodes() {
+    const lemmaHeaderNode = this.getLemmaHeaderNode(),
+          labelNodes = lemmaHeaderNode.getLabelNodes();
+
+    return labelNodes;
+  }
+
+  getSuppositionNodes() {
+    const lemmaBodyNode = this.getLemmaBodyNode(),
+          suppositionNodes = lemmaBodyNode.getSuppositionNodes();
+
+    return suppositionNodes;
+  }
+
+  getDeductionNode() {
+    const lemmaBodyNode = this.getLemmaBodyNode(),
+          deductionNode = lemmaBodyNode.getDeductionNode();
+
+    return deductionNode;
+  }
+
+  getProofNode() {
+    const lemmaBodyNode = this.getLemmaBodyNode(),
+          proofNode = lemmaBodyNode.getProofNode();
+
+    return proofNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(LemmaNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/metaLemma.js

@@ -1,7 +1,51 @@
 "use strict";
 
-import TopLevelMetaAssertionNode from "../node/topLevelMetaAssertion";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class MetaLemmaNode extends TopLevelMetaAssertionNode {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaLemmaNode, ruleName, childNodes, opacity, precedence); }
+import { META_LEMMA_BODY_RULE_NAME, META_LEMMA_HEADER_RULE_NAME } from "../ruleNames";
+
+export default class MetaLemmaNode extends NonTerminalNode {
+  getMetaLemmaBodyNode() {
+    const ruleName = META_LEMMA_BODY_RULE_NAME,
+          metaLemmaBodyNode = this.getNodeByRuleName(ruleName);
+
+    return metaLemmaBodyNode;
+  }
+
+  getMetaLemmaHeaderNode() {
+    const ruleName = META_LEMMA_HEADER_RULE_NAME,
+          metaLemmaHeaderNode = this.getNodeByRuleName(ruleName);
+
+    return metaLemmaHeaderNode;
+  }
+
+  getLabelNode() {
+    const metaLemmaHeaderNode = this.getMetaLemmaHeaderNode(),
+          labelNode = metaLemmaHeaderNode.getLabelNode();
+
+    return labelNode;
+  }
+
+  getSuppositionNodes() {
+    const metaLemmaBodyNode = this.getMetaLemmaBodyNode(),
+          suppositionNodes = metaLemmaBodyNode.getSuppositionNodes();
+
+    return suppositionNodes;
+  }
+
+  getDeductionNode() {
+    const metaLemmaBodyNode = this.getMetaLemmaBodyNode(),
+          deductionNode = metaLemmaBodyNode.getDeductionNode();
+
+    return deductionNode;
+  }
+
+  getProofNode() {
+    const metaLemmaBodyNode = this.getMetaLemmaBodyNode(),
+          proofNode = metaLemmaBodyNode.getProofNode();
+
+    return proofNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaLemmaNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/metatheorem.js

@@ -1,7 +1,51 @@
 "use strict";
 
-import TopLevelMetaAssertionNode from "../node/topLevelMetaAssertion";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class MetatheoremNode extends TopLevelMetaAssertionNode {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelMetaAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(MetatheoremNode, ruleName, childNodes, opacity, precedence); }
+import { METATHEOREM_BODY_RULE_NAME, METATHEOREM_HEADER_RULE_NAME } from "../ruleNames";
+
+export default class MetatheoremNode extends NonTerminalNode {
+  getMetatheoremBodyNode() {
+    const ruleName = METATHEOREM_BODY_RULE_NAME,
+          metatheoremBodyNode = this.getNodeByRuleName(ruleName);
+
+    return metatheoremBodyNode;
+  }
+
+  getMetatheoremHeaderNode() {
+    const ruleName = METATHEOREM_HEADER_RULE_NAME,
+          metatheoremHeaderNode = this.getNodeByRuleName(ruleName);
+
+    return metatheoremHeaderNode;
+  }
+
+  getLabelNode() {
+    const metatheoremHeaderNode = this.getMetatheoremHeaderNode(),
+          labelNode = metatheoremHeaderNode.getLabelNode();
+
+    return labelNode;
+  }
+
+  getSuppositionNodes() {
+    const metatheoremBodyNode = this.getMetatheoremBodyNode(),
+          suppositionNodes = metatheoremBodyNode.getSuppositionNodes();
+
+    return suppositionNodes;
+  }
+
+  getConclusionNode() {
+    const metatheoremBodyNode = this.getMetatheoremBodyNode(),
+          conclusionNode = metatheoremBodyNode.getConclusionNode();
+
+    return conclusionNode;
+  }
+
+  getProofNode() {
+    const metatheoremBodyNode = this.getMetatheoremBodyNode(),
+          proofNode = metatheoremBodyNode.getProofNode();
+
+    return proofNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetatheoremNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/qualification.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { REFERENCE_RULE_NAME, SATISFIES_ASSERTION_RULE_NAME } from "../ruleNames";
+
+export default class QualificationNode extends NonTerminalNode {
+  getReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          referenceNode = this.getNodeByRuleName(ruleName);
+
+    return referenceNode;
+  }
+
+  getSatisfiedAssertionNode() {
+    const ruleName = SATISFIES_ASSERTION_RULE_NAME,
+          satisfiedAssertionNode = this.getNodeByRuleName(ruleName);
+
+    return satisfiedAssertionNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(QualificationNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/rule.js

@@ -2,42 +2,49 @@
 
 import NonTerminalNode from "../node/nonTerminal";
 
-import {  PROOF_RULE_NAME, PREMISE_RULE_NAME, CONCLUSION_RULE_NAME, PARENTHESISED_LABELS_RULE_NAME } from "../ruleNames";
+import {RULE_BODY_RULE_NAME, RULE_HEADER_RULE_NAME} from "../ruleNames";
 
 export default class RuleNode extends NonTerminalNode {
-  getLabelNodes() {
-    const parenthesisedLabelsNode = this.getParenthesisedLabelsNode(),
-          labelNodes = parenthesisedLabelsNode.getLabelNodes();
+  getRuleBodyNode() {
+    const ruleName = RULE_BODY_RULE_NAME,
+          ruleBodyNode = this.getNodeByRuleName(ruleName);
 
-    return labelNodes;
+    return ruleBodyNode;
   }
 
-  getProofNode() {
-    const ruleName = PROOF_RULE_NAME,
-          proofNode = this.getNodeByRuleName(ruleName);
+  getRuleHeaderNode() {
+    const ruleName = RULE_HEADER_RULE_NAME,
+          ruleHeaderNode = this.getNodeByRuleName(ruleName);
 
-    return proofNode;
+    return ruleHeaderNode;
+  }
+
+  getLabelNodes() {
+    const ruleHeaderNode = this.getRuleHeaderNode(),
+          labelNodes = ruleHeaderNode.getLabelNodes();
+
+    return labelNodes;
   }
 
   getPremiseNodes() {
-    const ruleName = PREMISE_RULE_NAME,
-          premiseNodes = this.getNodesByRuleName(ruleName);
+    const ruleBodyNode = this.getRuleBodyNode(),
+          premiseNodes = ruleBodyNode.getPremiseNodes();
 
     return premiseNodes;
   }
 
   getConclusionNode() {
-    const ruleName = CONCLUSION_RULE_NAME,
-          conclusionNode = this.getNodeByRuleName(ruleName);
+    const ruleBodyNode = this.getRuleBodyNode(),
+          conclusionNode = ruleBodyNode.getConclusionNode();
 
     return conclusionNode;
   }
 
-  getParenthesisedLabelsNode() {
-    const ruleName = PARENTHESISED_LABELS_RULE_NAME,
-          parenthesisedLabelsNode = this.getNodeByRuleName(ruleName);
+  getProofNode() {
+    const ruleBodyNode = this.getRuleBodyNode(),
+          proofNode = ruleBodyNode.getProofNode();
 
-    return parenthesisedLabelsNode;
+    return proofNode;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(RuleNode, ruleName, childNodes, opacity, precedence); }

package/src/node/step.js

@@ -2,7 +2,7 @@
 
 import NonTerminalNode from "../node/nonTerminal";
 
-import { NONSENSE_RULE_NAME, REFERENCE_RULE_NAME, STATEMENT_RULE_NAME, SATISFIES_ASSERTION_RULE_NAME } from "../ruleNames";
+import { NONSENSE_RULE_NAME, STATEMENT_RULE_NAME, QUALIFICATION_RULE_NAME } from "../ruleNames";
 
 export default class StepNode extends NonTerminalNode {
   isStepNode() {
@@ -31,16 +31,33 @@ export default class StepNode extends NonTerminalNode {
     return statementNode;
   }
 
+  getQualificationNode() {
+    const ruleName = QUALIFICATION_RULE_NAME,
+          qualificationNode = this.getNodeByRuleName(ruleName);
+
+    return qualificationNode;
+  }
+
   getReferenceNode() {
-    const ruleName = REFERENCE_RULE_NAME,
-          referenceNode = this.getNodeByRuleName(ruleName);
+    let referenceNode = null;
+
+    const qualificationNode = this.getQualificationNode();
+
+    if (qualificationNode !== null) {
+      referenceNode = qualificationNode.getReferenceNode();
+    }
 
     return referenceNode;
   }
 
   getSatisfiedAssertionNode() {
-    const ruleName = SATISFIES_ASSERTION_RULE_NAME,
-          satisfiedAssertionNode = this.getNodeByRuleName(ruleName);
+    let satisfiedAssertionNode =  null;
+
+    const qualificationNode = this.getQualificationNode();
+
+    if (qualificationNode !== null) {
+      satisfiedAssertionNode = qualificationNode.getSatisfiedAssertionNode();
+    }
 
     return satisfiedAssertionNode;
   }

package/src/node/theorem.js

@@ -1,7 +1,51 @@
 "use strict";
 
-import TopLevelAssertionNode from "../node/topLevelAssertion";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class TheoremNode extends TopLevelAssertionNode {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(TheoremNode, ruleName, childNodes, opacity, precedence); }
+import { THEOREM_BODY_RULE_NAME, THEOREM_HEADER_RULE_NAME } from "../ruleNames";
+
+export default class TheoremNode extends NonTerminalNode {
+  getTheoremBodyNode() {
+    const ruleName = THEOREM_BODY_RULE_NAME,
+          theoremBodyNode = this.getNodeByRuleName(ruleName);
+
+    return theoremBodyNode;
+  }
+
+  getTheoremHeaderNode() {
+    const ruleName = THEOREM_HEADER_RULE_NAME,
+          theoremHeaderNode = this.getNodeByRuleName(ruleName);
+
+    return theoremHeaderNode;
+  }
+
+  getLabelsNode() {
+    const theoremHeaderNode = this.getTheoremHeaderNode(),
+          labelNodes = theoremHeaderNode.getLabelNodes();
+
+    return labelNodes;
+  }
+
+  getSuppositionNodes() {
+    const theoremBodyNode = this.getTheoremBodyNode(),
+          suppositionNodes = theoremBodyNode.getSuppositionNodes();
+
+    return suppositionNodes;
+  }
+
+  getDeductionNode() {
+    const theoremBodyNode = this.getTheoremBodyNode(),
+          deductionNode = theoremBodyNode.getDeductionNode();
+
+    return deductionNode;
+  }
+
+  getProofNode() {
+    const theoremBodyNode = this.getTheoremBodyNode(),
+          proofNode = theoremBodyNode.getProofNode();
+
+    return proofNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TheoremNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/nonTerminalNodeMap.js

@@ -22,6 +22,7 @@ import PropertyNode from "./node/property";
 import MetaTypeNode from "./node/metaType";
 import EqualityNode from "./node/equality";
 import VariableNode from "./node/variable";
+import ruleBodyNode from "./node/body/rule";
 import StatementNode from "./node/statement";
 import ReferenceNode from "./node/reference";
 import DeductionNode from "./node/deduction";
@@ -29,23 +30,37 @@ import JudgementNode from "./node/judgement";
 import MetaLemmaNode from "./node/metaLemma";
 import ParameterNode from "./node/parameter";
 import SignatureNode from "./node/signature";
+import axiomBodyNode from "./node/body/axiom";
+import lemmaBodyNode from "./node/body/lemma";
 import DerivationNode from "./node/derivation";
 import CombinatorNode from "./node/combinator";
 import ConclusionNode from "./node/conclusion";
 import ConjectureNode from "./node/conjecture";
 import HypothesisNode from "./node/hypothesis";
+import ruleHeaderNode from "./node/header/rule";
 import SuppositionNode from "./node/supposition";
 import ConstructorNode from "./node/constructor";
 import DeclarationNode from "./node/declaration";
 import MetatheoremNode from "./node/metatheorem";
+import theoremBodyNode from "./node/body/theorem";
+import axiomHeaderNode from "./node/header/axiom";
+import lemmaHeaderNode from "./node/header/lemma";
 import MetaArgumentNode from "./node/metaArgument";
 import MetavariableNode from "./node/metavariable";
+import QualificationNode from "./node/qualification";
+import theoremHeaderNode from "./node/header/theorem";
+import metaLemmaBodyNode from "./node/body/metaLemma";
 import ProcedureCallNode from "./node/procedureCall";
 import SubDerivationNode from "./node/subDerivation";
 import TypeAssertionNode from "./node/assertion/type";
+import conjectureBodyNode from "./node/body/conjecture";
+import metatheoremBodyNode from "./node/body/metatheorem";
+import metaLemmaHeaderNode from "./node/header/metaLemma";
 import PropertyRelationNode from "./node/propertyRelation"
 import DefinedAssertionNode from "./node/assertion/defined";
 import TermSubstitutionNode from "./node/substitution/term";
+import conjectureHeaderNode from "./node/header/conjecture";
+import metatheoremHeaderNode from "./node/header/metatheorem";
 import PropertyAssertionNode from "./node/assertion/property";
 import SubproofAssertionNode from "./node/assertion/subproof";
 import FrameSubstitutionNode from "./node/substitution/frame";
@@ -91,24 +106,39 @@ import { RULE_RULE_NAME,
          PARAMETER_RULE_NAME,
          REFERENCE_RULE_NAME,
          STATEMENT_RULE_NAME,
+         RULE_BODY_RULE_NAME,
          META_LEMMA_RULE_NAME,
          DERIVATION_RULE_NAME,
          COMBINATOR_RULE_NAME,
          CONCLUSION_RULE_NAME,
          CONJECTURE_RULE_NAME,
          HYPOTHESIS_RULE_NAME,
+         AXIOM_BODY_RULE_NAME,
+         LEMMA_BODY_RULE_NAME,
+         RULE_HEADER_RULE_NAME,
          CONSTRUCTOR_RULE_NAME,
          DECLARATION_RULE_NAME,
          SUPPOSITION_RULE_NAME,
          METATHEOREM_RULE_NAME,
+         AXIOM_HEADER_RULE_NAME,
+         LEMMA_HEADER_RULE_NAME,
+         THEOREM_BODY_RULE_NAME,
          METAVARIABLE_RULE_NAME,
+         QUALIFICATION_RULE_NAME,
          META_ARGUMENT_RULE_NAME,
+         THEOREM_HEADER_RULE_NAME,
          SUB_DERIVATION_RULE_NAME,
          TYPE_ASSERTION_RULE_NAME,
          PROCEDURE_CALL_RULE_NAME,
+         CONJECTURE_BODY_RULE_NAME,
+         META_LEMMA_BODY_RULE_NAME,
+         METATHEOREM_BODY_RULE_NAME,
+         CONJECTURE_HEADER_RULE_NAME,
+         META_LEMMA_HEADER_RULE_NAME,
          PROPERTY_RELATION_RULE_NAME,
          DEFINED_ASSERTION_RULE_NAME,
          TERM_SUBSTITUTION_RULE_NAME,
+         METATHEOREM_HEADER_RULE_NAME,
          SUBPROOF_ASSERTION_RULE_NAME,
          PROPERTY_ASSERTION_RULE_NAME,
          FRAME_SUBSTITUTION_RULE_NAME,
@@ -126,7 +156,7 @@ import { RULE_RULE_NAME,
          COMPLEX_TYPE_DECLARATION_RULE_NAME,
          METAVARIABLE_DECLARATION_RULE_NAME } from "./ruleNames";
 
-const nonTerminalNodeMap = {
+const NonTerminalNodeMap = {
   [RULE_RULE_NAME]: RuleNode,
   [STEP_RULE_NAME]: StepNode,
   [TERM_RULE_NAME]: TermNode,
@@ -148,6 +178,7 @@ const nonTerminalNodeMap = {
   [EQUALITY_RULE_NAME]: EqualityNode,
   [VARIABLE_RULE_NAME]: VariableNode,
   [NONSENSE_RULE_NAME]: NonsenseNode,
+  [RULE_BODY_RULE_NAME]: ruleBodyNode,
   [META_TYPE_RULE_NAME]: MetaTypeNode,
   [SIGNATURE_RULE_NAME]: SignatureNode,
   [REFERENCE_RULE_NAME]: ReferenceNode,
@@ -155,24 +186,38 @@ const nonTerminalNodeMap = {
   [DEDUCTION_RULE_NAME]: DeductionNode,
   [PARAMETER_RULE_NAME]: ParameterNode,
   [STATEMENT_RULE_NAME]: StatementNode,
+  [AXIOM_BODY_RULE_NAME]: axiomBodyNode,
+  [LEMMA_BODY_RULE_NAME]: lemmaBodyNode,
   [META_LEMMA_RULE_NAME]: MetaLemmaNode,
   [COMBINATOR_RULE_NAME]: CombinatorNode,
   [CONCLUSION_RULE_NAME]: ConclusionNode,
   [CONJECTURE_RULE_NAME]: ConjectureNode,
   [DERIVATION_RULE_NAME]: DerivationNode,
   [HYPOTHESIS_RULE_NAME]: HypothesisNode,
+  [RULE_HEADER_RULE_NAME]: ruleHeaderNode,
   [SUPPOSITION_RULE_NAME]: SuppositionNode,
   [CONSTRUCTOR_RULE_NAME]: ConstructorNode,
   [DECLARATION_RULE_NAME]: DeclarationNode,
   [METATHEOREM_RULE_NAME]: MetatheoremNode,
+  [AXIOM_HEADER_RULE_NAME]: axiomHeaderNode,
+  [LEMMA_HEADER_RULE_NAME]: lemmaHeaderNode,
+  [THEOREM_BODY_RULE_NAME]: theoremBodyNode,
   [METAVARIABLE_RULE_NAME]: MetavariableNode,
   [META_ARGUMENT_RULE_NAME]: MetaArgumentNode,
+  [QUALIFICATION_RULE_NAME]: QualificationNode,
   [TYPE_ASSERTION_RULE_NAME]: TypeAssertionNode,
   [PROCEDURE_CALL_RULE_NAME]: ProcedureCallNode,
   [SUB_DERIVATION_RULE_NAME]: SubDerivationNode,
+  [THEOREM_HEADER_RULE_NAME]: theoremHeaderNode,
+  [META_LEMMA_BODY_RULE_NAME]: metaLemmaBodyNode,
+  [CONJECTURE_BODY_RULE_NAME]: conjectureBodyNode,
+  [METATHEOREM_BODY_RULE_NAME]: metatheoremBodyNode,
+  [META_LEMMA_HEADER_RULE_NAME]: metaLemmaHeaderNode,
+  [CONJECTURE_HEADER_RULE_NAME]: conjectureHeaderNode,
   [PROPERTY_RELATION_RULE_NAME]: PropertyRelationNode,
   [DEFINED_ASSERTION_RULE_NAME]: DefinedAssertionNode,
   [TERM_SUBSTITUTION_RULE_NAME]: TermSubstitutionNode,
+  [METATHEOREM_HEADER_RULE_NAME]: metatheoremHeaderNode,
   [SUBPROOF_ASSERTION_RULE_NAME]: SubproofAssertionNode,
   [PROPERTY_ASSERTION_RULE_NAME]: PropertyAssertionNode,
   [FRAME_SUBSTITUTION_RULE_NAME]: FrameSubstitutionNode,
@@ -191,4 +236,4 @@ const nonTerminalNodeMap = {
   [METAVARIABLE_DECLARATION_RULE_NAME]: metavariableDeclarationNode
 };
 
-export default nonTerminalNodeMap;
+export default NonTerminalNodeMap;

package/src/ruleNames.js

@@ -28,24 +28,39 @@ export const DEDUCTION_RULE_NAME = "deduction";
 export const JUDGEMENT_RULE_NAME = "judgement";
 export const REFERENCE_RULE_NAME = "reference";
 export const STATEMENT_RULE_NAME = "statement";
+export const RULE_BODY_RULE_NAME = "ruleBody";
 export const META_LEMMA_RULE_NAME = "metaLemma";
 export const COMBINATOR_RULE_NAME = "combinator";
 export const CONCLUSION_RULE_NAME = "conclusion";
 export const CONJECTURE_RULE_NAME = "conjecture";
 export const DERIVATION_RULE_NAME = "derivation";
 export const HYPOTHESIS_RULE_NAME = "hypothesis";
+export const AXIOM_BODY_RULE_NAME = "axiomBody";
+export const LEMMA_BODY_RULE_NAME = "lemmaBody";
 export const SUPPOSITION_RULE_NAME = "supposition";
 export const CONSTRUCTOR_RULE_NAME = "constructor";
 export const DECLARATION_RULE_NAME = "declaration";
 export const METATHEOREM_RULE_NAME = "metatheorem";
+export const RULE_HEADER_RULE_NAME = "ruleHeader";
+export const AXIOM_HEADER_RULE_NAME = "axiomHeader";
+export const LEMMA_HEADER_RULE_NAME = "lemmaHeader";
+export const THEOREM_BODY_RULE_NAME = "theoremBody";
 export const METAVARIABLE_RULE_NAME = "metavariable";
 export const META_ARGUMENT_RULE_NAME = "metaArgument";
+export const QUALIFICATION_RULE_NAME = "qualification";
 export const PROCEDURE_CALL_RULE_NAME = "procedureCall";
 export const SUB_DERIVATION_RULE_NAME = "subDerivation";
 export const TYPE_ASSERTION_RULE_NAME = "typeAssertion";
+export const THEOREM_HEADER_RULE_NAME = "theoremHeader";
+export const CONJECTURE_BODY_RULE_NAME = "conjectureBody";
+export const META_LEMMA_BODY_RULE_NAME = "metaLemmaBody";
+export const METATHEOREM_BODY_RULE_NAME = "metatheoremBody";
 export const PROPERTY_RELATION_RULE_NAME = "propertyRelation";
 export const DEFINED_ASSERTION_RULE_NAME = "definedAssertion";
 export const TERM_SUBSTITUTION_RULE_NAME = "termSubstitution";
+export const CONJECTURE_HEADER_RULE_NAME = "conjectureHeader";
+export const META_LEMMA_HEADER_RULE_NAME = "metaLemmaHeader";
+export const METATHEOREM_HEADER_RULE_NAME = "metatheoremHeader";
 export const PROPERTY_ASSERTION_RULE_NAME = "propertyAssertion";
 export const SUBPROOF_ASSERTION_RULE_NAME = "subproofAssertion";
 export const FRAME_SUBSTITUTION_RULE_NAME = "frameSubstitution";