occam-verify-cli 1.0.444 → 1.0.457

package/src/element/{axiomLemmaTheoremConjecture.js → topLevelAssertion.js}

@@ -4,7 +4,7 @@ import { arrayUtilities } from "necessary";
 
 import Element from "../element";
 import elements from "../elements";
-import LocalContext from "../context/local";
+import ScopedContext from "../context/scoped";
 
 import { labelsFromJSON,
          deductionFromJSON,
@@ -19,7 +19,7 @@ import { labelsFromJSON,
 
 const { extract, reverse, correlate, backwardsEvery } = arrayUtilities;
 
-export default class AxiomLemmaTheoremConjecture extends Element {
+export default class TopLevelAssertion extends Element {
   constructor(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses) {
     super(context, string, node);
 
@@ -99,21 +99,21 @@ export default class AxiomLemmaTheoremConjecture extends Element {
     const hypothetical = this.isHypothetical();
 
     if (hypothetical) {
-      const steps = context.getSteps(),
+      const proofAssertions = context.getProofAssertions(),
             topLevelAssertionString = this.getString();  ///
 
-      context.trace(`Correlating the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture...`, this.node);
+      context.trace(`Correlating the hypotheses of the '${topLevelAssertionString}' top level assertion...`, this.node);
 
-      correlatesToHypotheses = correlate(this.hypotheses, steps, (hypothesis, step) => {
-        const hypothesesEqualToStep = hypothesis.isEqualToStep(step, context);
+      correlatesToHypotheses = correlate(this.hypotheses, proofAssertions, (hypothesis, proofAssertion) => {
+        const hypothesesComparesToStep = hypothesis.compareProofAssertion(proofAssertion, context);
 
-        if (hypothesesEqualToStep) {
+        if (hypothesesComparesToStep) {
           return true;
         }
       });
 
       if (correlatesToHypotheses) {
-        context.debug(`...correlated the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture.`, this.node);
+        context.debug(`...correlated the hypotheses of the '${topLevelAssertionString}' top level assertion.`, this.node);
       }
     } else {
       correlatesToHypotheses = true
@@ -128,8 +128,8 @@ export default class AxiomLemmaTheoremConjecture extends Element {
     const labelsVerify = this.verifyLabels();
 
     if (labelsVerify) {
-      const localContext = LocalContext.fromNothing(this.context),
-            context = localContext, ///
+      const scopedContext = ScopedContext.fromNothing(this.context),
+            context = scopedContext, ///
             suppositionsVerify = this.verifySuppositions(context);
 
       if (suppositionsVerify) {
@@ -212,7 +212,7 @@ export default class AxiomLemmaTheoremConjecture extends Element {
     return statementUnifiesWithDeduction;
   }
 
-  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context) {
+  unifyStatementAndStepsOrSubproofs(statement, subproofOrProofAssertions, substitutions, context) {
     let statementAndStepsOrSubproofsUnifies = false;
 
     const correlatesToHypotheses = this.correlateHypotheses(context);
@@ -221,9 +221,9 @@ export default class AxiomLemmaTheoremConjecture extends Element {
       const statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
 
       if (statementUnifiesWithDeduction) {
-        const stepsOrSubproofsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, context);
+        const subproofOrProofAssertionsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(subproofOrProofAssertions, substitutions, context);
 
-        if (stepsOrSubproofsUnifyWithSuppositions) {
+        if (subproofOrProofAssertionsUnifyWithSuppositions) {
           const substitutionsResolved = substitutions.areResolved();
 
           if (substitutionsResolved) {
@@ -236,43 +236,43 @@ export default class AxiomLemmaTheoremConjecture extends Element {
     return statementAndStepsOrSubproofsUnifies;
   }
 
-  unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext) {
-    let stepsOrSubproofsUnifiesWithSupposition = false;
+  unifyStepsOrSubproofsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext) {
+    let subproofOrProofAssertionsUnifiesWithSupposition = false;
 
     const context = specificContext,  ///
           suppositionUnifiesIndependently = supposition.unifyIndependently(substitutions, context);
 
     if (suppositionUnifiesIndependently) {
-      stepsOrSubproofsUnifiesWithSupposition = true;
+      subproofOrProofAssertionsUnifiesWithSupposition = true;
     } else {
-      const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {
-        const stepOrSubproofUnifies = supposition.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
+      const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
+        const subproofOrProofAssertionUnifies = supposition.unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, generalContext, specificContext);
 
-        if (stepOrSubproofUnifies) {
+        if (subproofOrProofAssertionUnifies) {
           return true;
         }
       }) || null;
 
-      if (stepOrSubproof !== null) {
-        stepsOrSubproofsUnifiesWithSupposition = true;
+      if (subproofOrProofAssertion !== null) {
+        subproofOrProofAssertionsUnifiesWithSupposition = true;
       }
     }
 
-    return stepsOrSubproofsUnifiesWithSupposition;
+    return subproofOrProofAssertionsUnifiesWithSupposition;
   }
 
-  unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext) {
-    stepsOrSubproofs = reverse(stepsOrSubproofs); ///
+  unifyStepsOrSubproofsWithSuppositions(subproofOrProofAssertions, substitutions, generalContext, specificContext) {
+    subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
 
-    const stepsOrSubproofsUnifyWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
-      const stepsOrSubproofsUnifiesWithSupposition = this.unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext);
+    const subproofOrProofAssertionsUnifyWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
+      const subproofOrProofAssertionsUnifiesWithSupposition = this.unifyStepsOrSubproofsWithSupposition(subproofOrProofAssertions, supposition, substitutions, generalContext, specificContext);
 
-      if (stepsOrSubproofsUnifiesWithSupposition) {
+      if (subproofOrProofAssertionsUnifiesWithSupposition) {
         return true;
       }
     });
 
-    return stepsOrSubproofsUnifyWithSuppositions;
+    return subproofOrProofAssertionsUnifyWithSuppositions;
   }
 
   toJSON() {
@@ -306,27 +306,8 @@ export default class AxiomLemmaTheoremConjecture extends Element {
           node = null,
           proof = null,
           string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
-          axiomLemmaTheoremConjecture = new Class(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
+          topLevelAssertion = new Class(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
-    return axiomLemmaTheoremConjecture;
-  }
-
-  static fromNode(Class, node, context) {
-    const topLevelAssertionNode = node, ///
-          proofNode = topLevelAssertionNode.getProofNode(),
-          labelNodes = topLevelAssertionNode.getLabelNodes(),
-          deductionNode = topLevelAssertionNode.getDeductionNode(),
-          suppositionNodes = topLevelAssertionNode.getSuppositionNodes(),
-          signatureNode = topLevelAssertionNode.getSignatureNode(),
-          proof = proofFromProofNode(proofNode, context),
-          labels = labelsFromLabelNodes(labelNodes, context),
-          deduction = deductionFromDeductionNode(deductionNode, context),
-          suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context),
-          signature = signatureFromSignatureNode(signatureNode, context),
-          hypotheses = [],
-          string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
-          axiomLemmaTheoremConjecture = new Class(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
-
-    return axiomLemmaTheoremConjecture;
+    return topLevelAssertion;
   }
 }

package/src/element/{metaLemma.js → topLevelMetaAssertion/metaLemma.js}

@@ -1,10 +1,10 @@
 "use strict";
 
-import MetaLemmaMetatheorem from "./metaLemmaMetatheorem";
+import TopLevelMetaAssertion from "./../topLevelMetaAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class MetaLemma extends MetaLemmaMetatheorem {
+export default define(class MetaLemma extends TopLevelMetaAssertion {
   verify() {
     let verifies;
 
@@ -30,5 +30,5 @@ export default define(class MetaLemma extends MetaLemmaMetatheorem {
 
   static name = "MetaLemma";
 
-  static fromJSON(json, context) { return MetaLemmaMetatheorem.fromJSON(MetaLemma, json, context); }
+  static fromJSON(json, context) { return TopLevelMetaAssertion.fromJSON(MetaLemma, json, context); }
 });

package/src/element/{metatheorem.js → topLevelMetaAssertion/metatheorem.js}

@@ -1,10 +1,10 @@
 "use strict";
 
-import MetaLemmaMetatheorem from "./metaLemmaMetatheorem";
+import TopLevelMetaAssertion from "../topLevelMetaAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Metatheorem extends MetaLemmaMetatheorem {
+export default define(class Metatheorem extends TopLevelMetaAssertion {
   verify() {
     let verifies;
 
@@ -30,5 +30,5 @@ export default define(class Metatheorem extends MetaLemmaMetatheorem {
 
   static name = "Metatheorem";
 
-  static fromJSON(json, context) { return MetaLemmaMetatheorem.fromJSON(Metatheorem, json, context); }
+  static fromJSON(json, context) { return TopLevelMetaAssertion.fromJSON(Metatheorem, json, context); }
 });

package/src/element/{metaLemmaMetatheorem.js → topLevelMetaAssertion.js}

@@ -1,10 +1,8 @@
 "use strict";
 
 import Element from "../element";
-import elements from "../elements";
-import LocalContext from "../context/local";
+import ScopedContext from "../context/scoped";
 
-import { proofFromProofNode, deductionFromDeductionNode, suppositionsFromSuppositionNodes } from "./axiomLemmaTheoremConjecture";
 import { labelFromJSON,
          labelToLabelJSON,
          deductionFromJSON,
@@ -14,7 +12,7 @@ import { labelFromJSON,
          suppositionsToSuppositionsJSON,
          substitutionsToSubstitutionsJSON } from "../utilities/json";
 
-export default class MetaLemmaMetatheorem extends Element {
+export default class TopLevelMetaAssertion extends Element {
   constructor(context, string, node, label, suppositions, deduction, proof, substitutions) {
     super(context, string, node);
 
@@ -61,8 +59,8 @@ export default class MetaLemmaMetatheorem extends Element {
     const labelVerifies = this.verifyLabel();
 
     if (labelVerifies) {
-      const localContext = LocalContext.fromNothing(this.context),
-            context = localContext, ///
+      const scopedContext = ScopedContext.fromNothing(this.context),
+            context = scopedContext, ///
             suppositionsVerify = this.verifySuppositions(context);
 
       if (suppositionsVerify) {
@@ -150,72 +148,9 @@ export default class MetaLemmaMetatheorem extends Element {
           substitutions = substitutionsFromJSON(json, context),
           node = null,
           proof = null,
-          string = stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
-          metaLemmaMetatheorem = new Class(context, string, node, label, suppositions, deduction, proof, substitutions);
+          string = topLevelMetaAssertionStringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
+          topLevelMetaAssertion = new Class(context, string, node, label, suppositions, deduction, proof, substitutions);
 
-    return metaLemmaMetatheorem;
+    return topLevelMetaAssertion;
   }
-
-  static fromNode(Class, node, context) {
-    const { Substitutions } = elements,
-          topLevelAssertionNode = node, ///
-          proofNode = topLevelAssertionNode.getProofNode(),
-          labelNode = topLevelAssertionNode.getLabelNode(),
-          deductionNode = topLevelAssertionNode.getDeductionNode(),
-          suppositionNodes = topLevelAssertionNode.getSuppositionNodes(),
-          proof = proofFromProofNode(proofNode, context),
-          label = labelFromLabelNode(labelNode, context),
-          deduction = deductionFromDeductionNode(deductionNode, context),
-          suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context),
-          substitutions = Substitutions.fromNothing(),
-          string = stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
-          metaLemmaMetatheorem = new Class(context, string, node, label, suppositions, deduction, proof, substitutions);
-
-    return metaLemmaMetatheorem;
-  }
-}
-
-function labelFromLabelNode(labelNode, context) {
-  let label = null;
-
-  const { Label } = elements;
-
-  if (labelNode !== null) {
-    label = Label.fromLabelNode(labelNode, context);
-  }
-
-  return label;
-}
-
-function labelStringFromLabel(label) {
-  const labelsString = (label !== null) ?
-                          label.getString() :
-                            null;
-
-  return labelsString;
-}
-
-function suppositionsStringFromSuppositions(suppositions) {
-  const suppositionsString = suppositions.reduce((suppositionsString, supposition) => {
-    const suppositionString = supposition.getString();
-
-    suppositionsString = (suppositionsString !== null) ?
-                          `${suppositionsString}, ${suppositionString}` :
-                            suppositionString;  ///
-
-    return suppositionsString;
-  }, null);
-
-  return suppositionsString;
-}
-
-function stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction) {
-  const suppositionsString = suppositionsStringFromSuppositions(suppositions),
-        deductionString = deduction.getString(),
-        labelString = labelStringFromLabel(label),
-        string = (labelString === null) ?
-                    deductionString : ///
-                     `${labelString} :: [${suppositionsString}] ... ${deductionString}`;
-
-  return string;
 }

package/src/element/type.js

@@ -321,14 +321,12 @@ export default define(class Type extends Element {
     return type;
   }
 
-  static fromName(name) {
-    const context = null,
-          string = name,  ///
+  static fromNameAndProvisional(name, provisional, context) {
+    const string = name,  ///
           node = null,
           prefixName = null,
           superTypes = [],
           properties = [],
-          provisional = false,
           type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
 
     return type;

package/src/element/variable.js

@@ -48,12 +48,12 @@ export default define(class Variable extends Element {
     return comparesToVariablbeIdentifier;
   }
 
-  verify(context) {
-    let verifies;
+  validate(context) {
+    let validates;
 
-    const variableString = this.string; ///
+    const variableString = this.getString(); ///
 
-    context.trace(`Verifying the '${variableString}' variable...`);
+    context.trace(`Validating the '${variableString}' variable...`);
 
     const variableIdentifier = this.identifier,
           variable = context.findVariableByVariableIdentifier(variableIdentifier);
@@ -63,24 +63,24 @@ export default define(class Variable extends Element {
 
       this.type = type;
 
-      verifies = true;
+      validates = true;
     } else {
       context.debug(`The '${variableString}' variable is not present.`);
     }
 
-    if (verifies) {
-      context.debug(`...verified the '${variableString}' variable.`);
+    if (validates) {
+      context.debug(`...validated the '${variableString}' variable.`);
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyType(context) {
-    let typeVerifies = false;
+  validateType(context) {
+    let typeValidates = false;
 
     const typeString = this.type.getString();
 
-    context.trace(`Verifying the '${typeString}' type...`);
+    context.trace(`Validating the '${typeString}' type...`);
 
     const prefixedTypeName = this.type.getPrefixedName(),
           type = context.findTypeByPrefixedTypeName(prefixedTypeName);
@@ -90,21 +90,21 @@ export default define(class Variable extends Element {
     } else {
       this.type = type; ///
 
-      typeVerifies = true;
+      typeValidates = true;
     }
 
-    if (typeVerifies) {
-      context.debug(`...verified the '${typeString}' type.`);
+    if (typeValidates) {
+      context.debug(`...validated the '${typeString}' type.`);
     }
 
-    return typeVerifies;
+    return typeValidates;
   }
 
   unifyTerm(term, substitutions, generalContext, specificContext) {
     let termUnifies = false;
 
     const termString = term.getString(),
-          variableString = this.string; ///
+          variableString = this.getString(); ///
 
     specificContext.trace(`Unifying the '${termString}' term with the '${variableString}' variable...`);
 
@@ -160,7 +160,7 @@ export default define(class Variable extends Element {
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
-          string = this.string, ///
+          string = this.getString(), ///
           type = typeJSON,  ///
           json = {
             type,

package/src/metaTypes.js

@@ -8,35 +8,64 @@ let frameMetaType = null,
     referenceMetaType = null,
     statementMetaType = null;
 
-export function frameMetaTypeFromNothing() {
+export function getMetaTypes() {
+  const frameMetaType = frameMetaTypeFromNothing(),
+        referenceMetaType = referenceMetaTypeFromNothing(),
+        statementMetaType = statementMetaTypeFromNothing(),
+        metaTypes = [
+          frameMetaType,
+          referenceMetaType,
+          statementMetaType
+        ];
+
+  return metaTypes;
+}
+
+export function findMetaTypeByMetaTypeName(metaTypeName) {
+  const metaTypes = getMetaTypes(),
+        metaType = metaTypes.find((metaType) => {
+          const metaTypeComparesToMetaTypeName = metaType.compareMetaTypeName(metaTypeName);
+
+          if (metaTypeComparesToMetaTypeName) {
+            return true;
+          }
+        }) || null;
+
+  return metaType;
+}
+
+function frameMetaTypeFromNothing() {
   if (frameMetaType === null) {
     const { MetaType } = elements,
-          name = FRAME_META_TYPE_NAME;  ///
+          name = FRAME_META_TYPE_NAME,  ///
+          context = null;
 
-    frameMetaType = MetaType.fromName(name);
+    frameMetaType = MetaType.fromName(name, context);
   }
 
   return frameMetaType;
 }
 
-export function referenceMetaTypeFromNothing() {
-  if (referenceMetaType === null) {
+function statementMetaTypeFromNothing() {
+  if (statementMetaType === null) {
     const { MetaType } = elements,
-          name = REFERENCE_META_TYPE_NAME;  ///
+          name = STATEMENT_META_TYPE_NAME,  ///
+          context = null;
 
-    referenceMetaType = MetaType.fromName(name);
+    statementMetaType = MetaType.fromName(name, context);
   }
 
-  return referenceMetaType;
+  return statementMetaType;
 }
 
-export function statementMetaTypeFromNothing() {
-  if (statementMetaType === null) {
+function referenceMetaTypeFromNothing() {
+  if (referenceMetaType === null) {
     const { MetaType } = elements,
-          name = STATEMENT_META_TYPE_NAME;  ///
+          name = REFERENCE_META_TYPE_NAME,  ///
+          context = null;
 
-    statementMetaType = MetaType.fromName(name);
+    referenceMetaType = MetaType.fromName(name, context);
   }
 
-  return statementMetaType;
+  return referenceMetaType;
 }

package/src/node/proofAssertion/premise.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import ProofAssertionNode from "../../node/proofAssertion";
+
+import { PROCEDURE_CALL_RULE_NAME } from "../../ruleNames";
+
+export default class PremiseNode extends ProofAssertionNode {
+  getProcedureCallNode() {
+    const ruleName = PROCEDURE_CALL_RULE_NAME,
+          procedureCallNode = this.getNodeByRuleName(ruleName);
+
+    return procedureCallNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return ProofAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(PremiseNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/{step.js → proofAssertion/step.js}

@@ -1,10 +1,10 @@
 "use strict";
 
-import NonTerminalNode from "../nonTerminalNode";
+import ProofAssertionNode from "../../node/proofAssertion";
 
-import { NONSENSE_RULE_NAME, STATEMENT_RULE_NAME, QUALIFICATION_RULE_NAME } from "../ruleNames";
+import { QUALIFICATION_RULE_NAME } from "../../ruleNames";
 
-export default class StepNode extends NonTerminalNode {
+export default class StepNode extends ProofAssertionNode {
   isStepNode() {
     const stepNode = true;
 
@@ -41,20 +41,6 @@ export default class StepNode extends NonTerminalNode {
     return satisfiedAssertionNode;
   }
 
-  getNonsenseNode() {
-    const ruleName = NONSENSE_RULE_NAME,
-          nonsenseNode = this.getNodeByRuleName(ruleName);
-
-    return nonsenseNode;
-  }
-
-  getStatementNode() {
-    const ruleName = STATEMENT_RULE_NAME,
-          statementNode = this.getNodeByRuleName(ruleName);
-
-    return statementNode;
-  }
-
   getQualificationNode() {
     const ruleName = QUALIFICATION_RULE_NAME,
           qualificationNode = this.getNodeByRuleName(ruleName);
@@ -62,5 +48,5 @@ export default class StepNode extends NonTerminalNode {
     return qualificationNode;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StepNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return ProofAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(StepNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/proofAssertion/supposition.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import ProofAssertionNode from "../../node/proofAssertion";
+
+import { PROCEDURE_CALL_RULE_NAME } from "../../ruleNames";
+
+export default class SuppositionNode extends ProofAssertionNode {
+  getProcedureCallNode() {
+    const ruleName = PROCEDURE_CALL_RULE_NAME,
+          procedureCallNode = this.getNodeByRuleName(ruleName);
+
+    return procedureCallNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return ProofAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(SuppositionNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/proofAssertion.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NonTerminalNode from "../nonTerminalNode";
+
+import { NONSENSE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class ProofAssertionNode extends NonTerminalNode {
+  getNonsenseNode() {
+    const ruleName = NONSENSE_RULE_NAME,
+          nonsenseNode = this.getNodeByRuleName(ruleName);
+
+    return nonsenseNode;
+  }
+
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/statement.js

@@ -36,7 +36,7 @@ export default class StatementNode extends NonTerminalNode {
 
     const metavariableNode = this.getMetavariableNode();
 
-    if (metavariableName !== null) {
+    if (metavariableNode !== null) {
       metavariableName = metavariableNode.getMetavariableName();
     }
 

package/src/node/subDerivation.js

@@ -5,13 +5,6 @@ import NonTerminalNode from "../nonTerminalNode";
 import { STEP_RULE_NAME, SUBPROOF_RULE_NAME } from "../ruleNames";
 
 export default class SubDerivationNode extends NonTerminalNode {
-  getLastStepNode() {
-    const ruleName = STEP_RULE_NAME,
-          lastStepNode = this.getLastNodeByRuleName(ruleName);
-
-    return lastStepNode;
-  }
-
   getStepOrSubproofNodes() {
     const ruleNames = [
             STEP_RULE_NAME,

package/src/node/subproof.js

@@ -17,13 +17,6 @@ export default class SubproofNode extends NonTerminalNode {
     return subproofNode;
   }
 
-  getLastStepNode() {
-    const subDerivationNode = this.getSubDerivationNode(),
-          lastStepNode = subDerivationNode.getLastStepNode();
-
-    return lastStepNode;
-  }
-
   getSuppositionNodes() {
     const ruleName = SUPPOSITION_RULE_NAME,
           suppositionNodes = this.getNodesByRuleName(ruleName);

package/src/node/substitution/statement.js

@@ -13,7 +13,7 @@ export default class StatementSubstitutionNode extends SubstitutionNode {
   }
 
   getMetavariableNode() {
-    const lastMetavariableNode = this.getLastVariableNode(),
+    const lastMetavariableNode = this.getLastMetavariableNode(),
           metavariableNode = lastMetavariableNode;  ///
 
     return metavariableNode;

package/src/node/topLevelAssertion/axiom.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import TopLevelAssertionNode from "../../node/topLevelAssertion";
+
+import { AXIOM_BODY_RULE_NAME, AXIOM_HEADER_RULE_NAME } from "../../ruleNames";
+
+export default class AxiomNode extends TopLevelAssertionNode {
+  static bodyRuleName = AXIOM_BODY_RULE_NAME;
+
+  static headerRuleName = AXIOM_HEADER_RULE_NAME;
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(AxiomNode, ruleName, childNodes, opacity, precedence); }
+}