occam-verify-cli 1.0.448 → 1.0.457

package/src/element/term.js

@@ -112,16 +112,15 @@ export default define(class Term extends Element {
     return validates;
   }
 
-  verifyGivenType(type, generalContext, specificContext) {
-    let verifiesGivenType;
+  validateGivenType(type, context) {
+    let validatesGivenType = false;
 
     const typeString = type.getString(),
           termString = this.getString();  ///
 
-    specificContext.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
+    context.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
 
-    const context = specificContext, ///
-          validates = this.validate(context, () => {
+    const validates = this.validate(context, () => {
             let verifiesAhead;
 
             const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);
@@ -133,13 +132,15 @@ export default define(class Term extends Element {
             return verifiesAhead;
           });
 
-    verifiesGivenType = validates; ///
+    if (validates) {
+      validatesGivenType = true;
+    }
 
-    if (verifiesGivenType) {
-      specificContext.debug(`...validated the '${termString}' term given the '${typeString}' type.`);
+    if (validatesGivenType) {
+      context.debug(`...validated the '${termString}' term given the '${typeString}' type.`);
     }
 
-    return verifiesGivenType;
+    return validatesGivenType;
   }
 
   toJSON() {

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

@@ -1,10 +1,10 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture  from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion  from "../../node/topLevelAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Axiom extends AxiomLemmaTheoremConjecture {
+export default define(class Axiom extends TopLevelAssertion {
   isSatisfiable() {
     const signature = this.getSignature(),
           satisfiable = (signature !== null);
@@ -225,19 +225,19 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     return lastProofAssertionUnifies;
   }
 
-  unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, substitutions, context) {
-    let axiomLemmaTheoremOrConjectureUnifies = false;
+  unifyTopLevelAssertion(topLevelAssertion, substitutions, context) {
+    let topLevelAssertionUnifies = false;
 
     const node = this.getNode(),
           axiomString = this.getString(),
-          axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString();
+          topLevelAssertionString = topLevelAssertion.getString();
 
-    context.trace(`Unifying the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom...`, node);
+    context.trace(`Unifying the '${topLevelAssertionString}' top level assertion with the '${axiomString}' axiom...`, node);
 
-    const hypothesesCorrelate = axiomLemmaTheoremOrConjecture.correlateHypotheses(context);
+    const hypothesesCorrelate = topLevelAssertion.correlateHypotheses(context);
 
     if (hypothesesCorrelate) {
-      const deduction = axiomLemmaTheoremOrConjecture.getDeduction(),  ///
+      const deduction = topLevelAssertion.getDeduction(),  ///
             specificContext = context;  ///
 
       context = this.getContext();
@@ -246,21 +246,21 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
             deductionUnifies = this.unifyDeduction(deduction, substitutions, generalContext, specificContext);
 
       if (deductionUnifies) {
-        const suppositions = axiomLemmaTheoremOrConjecture.getSuppositions(),
+        const suppositions = topLevelAssertion.getSuppositions(),
               suppositionsUnify = this.unifySuppositions(suppositions, substitutions, generalContext, specificContext);
 
-        axiomLemmaTheoremOrConjectureUnifies = suppositionsUnify; ///
+        topLevelAssertionUnifies = suppositionsUnify; ///
       }
     }
 
-    if (axiomLemmaTheoremOrConjectureUnifies) {
-      context.debug(`...unified the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom.`, node);
+    if (topLevelAssertionUnifies) {
+      context.debug(`...unified the '${topLevelAssertionString}' top level assertion with the '${axiomString}' axiom.`, node);
     }
 
-    return axiomLemmaTheoremOrConjectureUnifies;
+    return topLevelAssertionUnifies;
   }
 
   static name = "Axiom";
 
-  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Axiom, json, context); }
+  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Axiom, json, context); }
 });

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

@@ -1,10 +1,10 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion from "../topLevelAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Conjecture extends AxiomLemmaTheoremConjecture {
+export default define(class Conjecture extends TopLevelAssertion {
   verify() {
     let verifies;
 
@@ -30,5 +30,5 @@ export default define(class Conjecture extends AxiomLemmaTheoremConjecture {
 
   static name = "Conjecture";
 
-  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Conjecture, json, context); }
+  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Conjecture, json, context); }
 });

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

@@ -1,10 +1,10 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion from "../topLevelAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Lemma extends AxiomLemmaTheoremConjecture {
+export default define(class Lemma extends TopLevelAssertion {
   verify() {
     let verifies;
 

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

@@ -1,10 +1,10 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion from "../topLevelAssertion";
 
-import { define } from "../elements";
+import { define } from "../../elements";
 
-export default define(class Theorem extends AxiomLemmaTheoremConjecture {
+export default define(class Theorem extends TopLevelAssertion {
   verify() {
     let verifies;
 
@@ -29,5 +29,5 @@ export default define(class Theorem extends AxiomLemmaTheoremConjecture {
 
   static name = "Theorem";
 
-  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, context); }
+  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Theorem, json, context); }
 });

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);
 
@@ -100,9 +100,9 @@ export default class AxiomLemmaTheoremConjecture extends Element {
 
     if (hypothetical) {
       const proofAssertions = context.getProofAssertions(),
-            axiomLemmaTheoremConjectureString = this.getString();  ///
+            topLevelAssertionString = this.getString();  ///
 
-      context.trace(`Correlating the hypotheses of the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture...`, this.node);
+      context.trace(`Correlating the hypotheses of the '${topLevelAssertionString}' top level assertion...`, this.node);
 
       correlatesToHypotheses = correlate(this.hypotheses, proofAssertions, (hypothesis, proofAssertion) => {
         const hypothesesComparesToStep = hypothesis.compareProofAssertion(proofAssertion, context);
@@ -113,7 +113,7 @@ export default class AxiomLemmaTheoremConjecture extends Element {
       });
 
       if (correlatesToHypotheses) {
-        context.debug(`...correlated the hypotheses of the '${axiomLemmaTheoremConjectureString}' 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) {
@@ -306,8 +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;
+    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,7 +1,7 @@
 "use strict";
 
 import Element from "../element";
-import LocalContext from "../context/local";
+import ScopedContext from "../context/scoped";
 
 import { labelFromJSON,
          labelToLabelJSON,
@@ -12,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);
 
@@ -59,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) {
@@ -148,9 +148,9 @@ export default class MetaLemmaMetatheorem extends Element {
           substitutions = substitutionsFromJSON(json, context),
           node = null,
           proof = null,
-          string = metaLemmaMetatheoremStringFromLabelASuppositionsAndDeduction(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;
   }
 }

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

@@ -21,34 +21,50 @@ export function getMetaTypes() {
   return metaTypes;
 }
 
-export function frameMetaTypeFromNothing() {
+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 statementMetaTypeFromNothing() {
+function statementMetaTypeFromNothing() {
   if (statementMetaType === null) {
     const { MetaType } = elements,
-          name = STATEMENT_META_TYPE_NAME;  ///
+          name = STATEMENT_META_TYPE_NAME,  ///
+          context = null;
 
-    statementMetaType = MetaType.fromName(name);
+    statementMetaType = MetaType.fromName(name, context);
   }
 
   return statementMetaType;
 }
 
-export function referenceMetaTypeFromNothing() {
+function referenceMetaTypeFromNothing() {
   if (referenceMetaType === null) {
     const { MetaType } = elements,
-          name = REFERENCE_META_TYPE_NAME;  ///
+          name = REFERENCE_META_TYPE_NAME,  ///
+          context = null;
 
-    referenceMetaType = MetaType.fromName(name);
+    referenceMetaType = MetaType.fromName(name, context);
   }
 
   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/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); }
+}

package/src/node/topLevelAssertion/conjecture.js

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

package/src/node/topLevelAssertion/lemma.js

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

package/src/node/topLevelAssertion/theorem.js

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