occam-verify-cli 1.0.421 → 1.0.428

package/src/node/substitution/term.js

@@ -5,6 +5,20 @@ import SubstitutionNode from "../../node/substitution";
 import { TERM_RULE_NAME } from "../../ruleNames";
 
 export default class TermSubstitutionNode extends SubstitutionNode {
+  getVariableNode() {
+    const lastVariableNode = this.getLastVariableNode(),
+          variableNode = lastVariableNode;  ///
+
+    return variableNode;
+  }
+
+  getTermNode() {
+    const firstTermNode = this.getFirstTermNode(),
+          termNode = firstTermNode; ///
+
+    return termNode;
+  }
+
   getLastTermNode() {
     const ruleName = TERM_RULE_NAME,
           lastTermNode = this.getLastNodeByRuleName(ruleName);
@@ -37,3 +51,4 @@ export default class TermSubstitutionNode extends SubstitutionNode {
 
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(TermSubstitutionNode, ruleName, childNodes, opacity, precedence); }
 }
+

package/src/nonTerminalNodeMap.js

@@ -44,10 +44,11 @@ import RuleHeaderNode from "./node/header/rule";
 import SuppositionNode from "./node/supposition";
 import PlaceholderNode from "./node/placeholder";
 import ConstructorNode from "./node/constructor";
-import MetatheoremNode from "./node/metatheorem";
 import TheoremBodyNode from "./node/body/theorem";
 import AxiomHeaderNode from "./node/header/axiom";
 import LemmaHeaderNode from "./node/header/lemma";
+import MetatheoremNode from "./node/metatheorem";
+import EquivalenceNode from "./node/equivalence";
 import MetaArgumentNode from "./node/metaArgument";
 import MetavariableNode from "./node/metavariable";
 import QualificationNode from "./node/qualification";
@@ -128,6 +129,7 @@ import {
   RULE_HEADER_RULE_NAME,
   CONSTRUCTOR_RULE_NAME,
   METATHEOREM_RULE_NAME,
+  EQUIVALENCE_RULE_NAME,
   AXIOM_HEADER_RULE_NAME,
   LEMMA_HEADER_RULE_NAME,
   THEOREM_BODY_RULE_NAME,
@@ -211,6 +213,7 @@ const NonTerminalNodeMap = {
   [SUPPOSITION_RULE_NAME]: SuppositionNode,
   [CONSTRUCTOR_RULE_NAME]: ConstructorNode,
   [METATHEOREM_RULE_NAME]: MetatheoremNode,
+  [EQUIVALENCE_RULE_NAME]: EquivalenceNode,
   [AXIOM_HEADER_RULE_NAME]: AxiomHeaderNode,
   [LEMMA_HEADER_RULE_NAME]: LemmaHeaderNode,
   [THEOREM_BODY_RULE_NAME]: TheoremBodyNode,

package/src/preamble.js

@@ -1,64 +1,64 @@
 "use strict";
 
-import Type from "./ontology/type";
-import Term from "./ontology/term";
-import Rule from "./ontology/rule";
-import Step from "./ontology/step";
-import Label from "./ontology/label";
-import Axiom from "./ontology/axiom";
-import Lemma from "./ontology/lemma";
-import Frame from "./ontology/frame";
-import Proof from "./ontology/proof";
-import Error from "./ontology/error";
-import Premise from "./ontology/premise";
-import Theorem from "./ontology/theorem";
-import Section from "./ontology/section";
-import Equality from "./ontology/equality";
-import MetaType from "./ontology/metaType";
-import Subproof from "./ontology/subproof";
-import Variable from "./ontology/variable";
-import Property from "./ontology/property";
-import Parameter from "./ontology/parameter";
-import Reference from "./ontology/reference";
-import Statement from "./ontology/statement";
-import Judgement from "./ontology/judgement";
-import MetaLemma from "./ontology/metaLemma";
-import Deduction from "./ontology/deduction";
-import Signature from "./ontology/signature";
-import TypePrefix from "./ontology/typePrefix";
-import Conjecture from "./ontology/conjecture";
-import Conclusion from "./ontology/conclusion";
-import Derivation from "./ontology/derivation";
-import Combinator from "./ontology/combinator";
-import Hypothesis from "./ontology/hypothesis";
-import Assumption from "./ontology/assumption";
-import Constructor from "./ontology/constructor";
-import Supposition from "./ontology/supposition";
-import Metatheorem from "./ontology/metatheorem";
-import Equivalence from "./ontology/equivalence";
-import Equivalences from "./ontology/equivalences";
-import Metavariable from "./ontology/metavariable";
-import Substitutions from "./ontology/substitutions";
-import ProcedureCall from "./ontology/procedureCall";
-import SubDerivation from "./ontology/subDerivation";
-import TypeAssertion from "./ontology/assertion/type";
-import PropertyRelation from "./ontology/propertyRelation";
-import DefinedAssertion from "./ontology/assertion/defined";
-import TermSubstitution from "./ontology/substitution/term";
-import FrameSubstitution from "./ontology/substitution/frame";
-import SubproofAssertion from "./ontology/assertion/subproof";
-import PropertyAssertion from "./ontology/assertion/property";
-import ProcedureReference from "./ontology/procedureReference";
-import ContainedAssertion from "./ontology/assertion/contained";
-import SatisfiesAssertion from "./ontology/assertion/satisfies";
-import VariableDeclaration from "./ontology/declaration/variable";
-import BracketedCombinator from "./ontology/combinator/bracketed";
-import BracketedConstructor from "./ontology/constructor/bracketed";
-import SimpleTypeDeclaration from "./ontology/declaration/simpleType";
-import StatementSubstitution from "./ontology/substitution/statement";
-import ReferenceSubstitution from "./ontology/substitution/reference";
-import CombinatorDeclaration from "./ontology/declaration/combinator";
-import TypePrefixDeclaration from "./ontology/declaration/typePrefix";
-import ConstructorDeclaration from "./ontology/declaration/constructor";
-import ComplexTypeDeclaration from "./ontology/declaration/complexType";
-import MetavariableDeclaration from "./ontology/declaration/metavariable";
+import Type from "./element/type";
+import Term from "./element/term";
+import Rule from "./element/rule";
+import Step from "./element/step";
+import Label from "./element/label";
+import Axiom from "./element/axiom";
+import Lemma from "./element/lemma";
+import Frame from "./element/frame";
+import Proof from "./element/proof";
+import Error from "./element/error";
+import Premise from "./element/premise";
+import Theorem from "./element/theorem";
+import Section from "./element/section";
+import Equality from "./element/equality";
+import MetaType from "./element/metaType";
+import Subproof from "./element/subproof";
+import Variable from "./element/variable";
+import Property from "./element/property";
+import Parameter from "./element/parameter";
+import Reference from "./element/reference";
+import Statement from "./element/statement";
+import Judgement from "./element/judgement";
+import MetaLemma from "./element/metaLemma";
+import Deduction from "./element/deduction";
+import Signature from "./element/signature";
+import TypePrefix from "./element/typePrefix";
+import Conjecture from "./element/conjecture";
+import Conclusion from "./element/conclusion";
+import Derivation from "./element/derivation";
+import Hypothesis from "./element/hypothesis";
+import Assumption from "./element/assumption";
+import Supposition from "./element/supposition";
+import Metatheorem from "./element/metatheorem";
+import Equivalence from "./element/equivalence";
+import Equivalences from "./element/equivalences";
+import Metavariable from "./element/metavariable";
+import Substitutions from "./element/substitutions";
+import ProcedureCall from "./element/procedureCall";
+import SubDerivation from "./element/subDerivation";
+import TypeAssertion from "./element/assertion/type";
+import ConstructorTerm from "./element/term/constructor";
+import PropertyRelation from "./element/propertyRelation";
+import DefinedAssertion from "./element/assertion/defined";
+import TermSubstitution from "./element/substitution/term";
+import FrameSubstitution from "./element/substitution/frame";
+import SubproofAssertion from "./element/assertion/subproof";
+import PropertyAssertion from "./element/assertion/property";
+import ProcedureReference from "./element/procedureReference";
+import ContainedAssertion from "./element/assertion/contained";
+import SatisfiesAssertion from "./element/assertion/satisfies";
+import VariableDeclaration from "./element/declaration/variable";
+import CombinatorStatement from "./element/statement/combinator";
+import SimpleTypeDeclaration from "./element/declaration/simpleType";
+import StatementSubstitution from "./element/substitution/statement";
+import ReferenceSubstitution from "./element/substitution/reference";
+import CombinatorDeclaration from "./element/declaration/combinator";
+import TypePrefixDeclaration from "./element/declaration/typePrefix";
+import ConstructorDeclaration from "./element/declaration/constructor";
+import ComplexTypeDeclaration from "./element/declaration/complexType";
+import MetavariableDeclaration from "./element/declaration/metavariable";
+import BracketedConstructorTerm from "./element/term/constructor/bracketed";
+import BracketedCombinatorStatement from "./element/statement/combinator/bracketed";

package/src/process/assign.js

@@ -0,0 +1,59 @@
+"use strict";
+
+export function judgementAssignmentFromJudgement(judgement) {
+  return function (context) {
+    const judgementString = judgement.getString(),
+          judgementAdded = context.addJudgement(judgement),
+          assigned = judgementAdded; ///
+
+    assigned ?
+      context.trace(`Assigned the '${judgementString}' judgement.`) :
+        context.debug(`Unable to assign the '${judgementString}' judgement.`);
+
+    return assigned;
+  };
+}
+
+export function equalityAssignmentFromEquality(equality) {
+  return function (context) {
+    const equalityString = equality.getString(),
+          equalityAdded = context.addEquality(equality),
+          assigned = equalityAdded; ///
+
+    assigned ?
+      context.trace(`Assigned the '${equalityString}' equality.`) :
+        context.debug(`Unable to assign the '${equalityString}' equality.`);
+
+    return assigned;
+  };
+}
+
+export function variableAssignmentFromVariable(variable) {
+  return function (context) {
+    const nested = false;
+
+    context.addVariable(variable, nested);
+
+    const variableTypeString = variable.getTypeString(),
+          variableString = variable.getString(),
+          assigned = true;
+
+    assigned ?
+      context.trace(`Assigned the '${variableString}' variable with type '${variableTypeString}'.`) :
+        context.debug(`Unable to assign the '${variableString}' variable with type '${variableTypeString}'.`);
+
+    return assigned;
+  };
+}
+
+export default function assignAssignments(assignments, context) {
+  const assignmentsAssigned = assignments.every((assigment) => {
+    const assigned = assigment(context);
+
+    if (assigned) {
+      return true;
+    }
+  });
+
+  return assignmentsAssigned;
+}

package/src/process/instantiate.js

@@ -1,23 +1,79 @@
 "use strict";
 
+import nominalContext from "../context/nominal";
+
 import { ruleFromBNF } from "../utilities/bnf";
+import { BASE_TYPE_SYMBOL } from "../constants";
+import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
+
+const termPlaceholderBNF = ` _ ::= term... <END_OF_LINE> ; `,
+      variablePlaceholderBNF = ` _ ::= variable... <END_OF_LINE> ; `,
+      statementPlaceholderBNF = ` _ ::= statement... <END_OF_LINE> ; `,
+      equivalencePlaceholderBNF = ` _ ::= equivalence... <END_OF_LINE> ; `,
+      metavariablePlaceholderBNF = ` _ ::= metavariable... <END_OF_LINE> ; `,
+      termSubstitutionPlaceholderBNF = ` _ ::= termSubstitution... <END_OF_LINE> ; `,
+      frameSubstitutionPlaceholderBNF = ` _ ::= frameSubstitution... <END_OF_LINE> ; `,
+      statementSubstitutionPlaceholderBNF = ` _ ::= statementSubstitution... <END_OF_LINE> ; `,
+      referenceSubstitutionPlaceholderBNF = ` _ ::= referenceSubstitution... <END_OF_LINE> ; `,
+      termPlaceholderRule = ruleFromBNF(termPlaceholderBNF),
+      variablePlaceholderRule = ruleFromBNF(variablePlaceholderBNF),
+      statementPlaceholderRule = ruleFromBNF(statementPlaceholderBNF),
+      equivalencePlaceholderRule = ruleFromBNF(equivalencePlaceholderBNF),
+      metavariablePlaceholderRule = ruleFromBNF(metavariablePlaceholderBNF),
+      termSubstitutionPlaceholderRule = ruleFromBNF(termSubstitutionPlaceholderBNF),
+      frameSubstitutionPlaceholderRule = ruleFromBNF(frameSubstitutionPlaceholderBNF),
+      statementSubstitutionPlaceholderRule = ruleFromBNF(statementSubstitutionPlaceholderBNF),
+      referenceSubstitutionPlaceholderRule = ruleFromBNF(referenceSubstitutionPlaceholderBNF);
+
+let bracketedConstructorTermNode = null,
+    bracketedCombinatorStatementNode = null;
+
+export const bracketedConstructorTermString = `(${BASE_TYPE_SYMBOL})`;
+export const bracketedCombinatorStatementString = `(${STATEMENT_META_TYPE_NAME})`;
+
+export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, string, context); }
+
+export function instantiateVariable(string, context) { return instantiate(variablePlaceholderRule, string, context); }
+
+export function instantiateStatement(string, context) { return instantiate(statementPlaceholderRule, string, context); }
+
+export function instantiateEquivalence(string, context) { return instantiate(equivalencePlaceholderRule, string, context); }
 
-const termSubtitutionnPlaceholderBNF = ` _ ::= termSubstitution... <END_OF_LINE> ; `,
-      frameSubtitutionnPlaceholderBNF = ` _ ::= frameSubstitution... <END_OF_LINE> ; `,
-      statementSubtitutionnPlaceholderBNF = ` _ ::= statementSubstitution... <END_OF_LINE> ; `,
-      referenceSubtitutionnPlaceholderBNF = ` _ ::= referenceSubstitution... <END_OF_LINE> ; `,
-      termSubtitutionnPlaceholderRule = ruleFromBNF(termSubtitutionnPlaceholderBNF),
-      frameSubtitutionnPlaceholderRule = ruleFromBNF(frameSubtitutionnPlaceholderBNF),
-      statementSubtitutionnPlaceholderRule = ruleFromBNF(statementSubtitutionnPlaceholderBNF),
-      referenceSubtitutionnPlaceholderRule = ruleFromBNF(referenceSubtitutionnPlaceholderBNF);
+export function instantiateMetavariable(string, context) { return instantiate(metavariablePlaceholderRule, string, context); }
 
-export function instantiateTermSubstitution(string, context) { return instantiate(termSubtitutionnPlaceholderRule, string, context); }
+export function instantiateTermSubstitution(string, context) { return instantiate(termSubstitutionPlaceholderRule, string, context); }
 
-export function instantiateFrameSubstitution(string, context) { return instantiate(frameSubtitutionnPlaceholderRule, string, context); }
+export function instantiateFrameSubstitution(string, context) { return instantiate(frameSubstitutionPlaceholderRule, string, context); }
 
-export function instantiateStatementSubstitution(string, context) { return instantiate(statementSubtitutionnPlaceholderRule, string, context); }
+export function instantiateStatementSubstitution(string, context) { return instantiate(statementSubstitutionPlaceholderRule, string, context); }
 
-export function instantiateReferenceSubstitution(string, context) { return instantiate(referenceSubtitutionnPlaceholderRule, string, context); }
+export function instantiateReferenceSubstitution(string, context) { return instantiate(referenceSubstitutionPlaceholderRule, string, context); }
+
+export function instantiateBracketedConstructorTerm() {
+  if (bracketedConstructorTermNode === null) {
+    const placeholderRule = termPlaceholderRule, ///
+          string = bracketedConstructorTermString,
+          context = nominalContext, ///
+          node = instantiate(placeholderRule, string, context);
+
+    bracketedConstructorTermNode = node;  ///
+  }
+
+  return bracketedConstructorTermNode;
+}
+
+export function instantiateBracketedCombinatorStatement() {
+  if (bracketedCombinatorStatementNode === null) {
+    const placeholderRule = statementPlaceholderRule, ///
+          string = bracketedCombinatorStatementString,  ///
+          context = nominalContext, ///
+          node = instantiate(placeholderRule, string, context);
+
+    bracketedCombinatorStatementNode = node;  ///
+  }
+
+  return bracketedCombinatorStatementNode;
+}
 
 function instantiate(placeholderRule, string, context) {
   let node;
@@ -26,8 +82,8 @@ function instantiate(placeholderRule, string, context) {
         parser = context.getParser(),
         content = `${string}
 `,
-        startRule = placeholderRule, ///
-        tokens = lexer.tokenise(content);
+        tokens = lexer.tokenise(content),
+        startRule = placeholderRule;  ///
 
   node = parser.parse(tokens, startRule);
 
@@ -37,7 +93,7 @@ function instantiate(placeholderRule, string, context) {
     node = childNode; ///
 
     return true;
-  })
+  });
 
   return node;
 }

package/src/process/unify.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import ontology from "../ontology";
+import elements from "../elements";
 
 import { nodeQuery } from "../utilities/query";
 import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual, isLastRemainingArgumentFunction } from "../utilities/pass";
@@ -346,7 +346,7 @@ class CombinatorPass extends Pass {
 
         context = specificContext;  ///
 
-        const { Statement } = ontology,
+        const { Statement } = elements,
               statement = Statement.fromStatementNode(statementNode, context),
               statementVerifiesGivenType = statement.verifyGivenMetaType(metaType, assignments, stated, context);
 
@@ -375,7 +375,7 @@ class CombinatorPass extends Pass {
 
         context = specificContext;  ///
 
-        const { Frame } = ontology,
+        const { Frame } = elements,
               frame = Frame.fromFrameNode(frameNode, context),
               frameVerifiesGivenType = frame.verifyGivenMetaType(metaType, assignments, stated, context);
 
@@ -405,7 +405,7 @@ class CombinatorPass extends Pass {
         if (type !== null) {
           context = specificContext;  ///
 
-          const { Term } = ontology,
+          const { Term } = elements,
                 term = Term.fromTermNode(termNode, context),
                 termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
 
@@ -441,7 +441,7 @@ class ConstructorPass extends Pass {
         if (type !== null) {
           context = specificContext;  ///
 
-          const { Term } = ontology,
+          const { Term } = elements,
                 term = Term.fromTermNode(termNode, context),
                 termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
 
@@ -567,23 +567,6 @@ export function unifyMetavariable(generalMetavariable, specificMetavariable, gen
   return metavariableUnifies;
 }
 
-export function unifyTermWithConstructor(term, constructor, context) {
-  let termUnifiesWithConstructor = false;
-
-  const termNode = term.getNode(),
-        generalContext = context, ///
-        specificContext = context,  ///
-        constructorTerm = constructor.getTerm(),
-        constructorTermNode = constructorTerm.getNode(),
-        success = constructorPass.run(constructorTermNode, termNode, generalContext, specificContext);
-
-  if (success) {
-    termUnifiesWithConstructor = true;
-  }
-
-  return termUnifiesWithConstructor;
-}
-
 export function unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext) {
   let statementUnifiesIntrinsically = false;
 
@@ -600,23 +583,6 @@ export function unifyStatementIntrinsically(generalStatement, specificStatement,
   return statementUnifiesIntrinsically;
 }
 
-export function unifyStatementWithCombinator(statement, combinator, assignments, stated, context) {
-  let statementUnifiesWithCombinator = false;
-
-  const statementNode = statement.getNode(),
-        generalContext = context, ///
-        specificContext = context,  ///
-        combinatorStatement = combinator.getStatement(),
-        combinatorStatementNode = combinatorStatement.getNode(),
-        success = combinatorPass.run(combinatorStatementNode, statementNode, assignments, stated, generalContext, specificContext);
-
-  if (success) {
-    statementUnifiesWithCombinator = true;
-  }
-
-  return statementUnifiesWithCombinator;
-}
-
 export function unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext) {
   let metavariableUnifiesIntrinsically = false;
 
@@ -632,3 +598,35 @@ export function unifyMetavariableIntrinsically(generalMetavariable, specificMeta
 
   return metavariableUnifiesIntrinsically;
 }
+
+export function unifyTermWithConstructorTerm(term, constructorTerm, context) {
+  let termUnifiesWithConstructor = false;
+
+  const termNode = term.getNode(),
+        generalContext = context, ///
+        specificContext = context,  ///
+        constructorTermNode = constructorTerm.getNode(),
+        success = constructorPass.run(constructorTermNode, termNode, generalContext, specificContext);
+
+  if (success) {
+    termUnifiesWithConstructor = true;
+  }
+
+  return termUnifiesWithConstructor;
+}
+
+export function unifyStatementWithCombinatorStatement(statement, combinatorStatement, assignments, stated, context) {
+  let statementUnifiesWithCombinator = false;
+
+  const statementNode = statement.getNode(),
+        generalContext = context, ///
+        specificContext = context,  ///
+        combinatorStatementNode = combinatorStatement.getNode(),
+        success = combinatorPass.run(combinatorStatementNode, statementNode, assignments, stated, generalContext, specificContext);
+
+  if (success) {
+    statementUnifiesWithCombinator = true;
+  }
+
+  return statementUnifiesWithCombinator;
+}

package/src/process/verify.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import ontology from "../ontology";
+import elements from "../elements";
 
 import { nodeQuery } from "../utilities/query";
 import { isLastRemainingArgumentFunction } from "../utilities/pass";
@@ -182,7 +182,7 @@ class TopLevelPass extends Pass {
       run: (errorNode, context) => {
         let success = false;
 
-        const { Error } = ontology,
+        const { Error } = elements,
               error = Error.fromErrorNode(errorNode, context),
               errorVerifies = error.verify();
 
@@ -198,7 +198,7 @@ class TopLevelPass extends Pass {
       run: (ruleNode, context) => {
         let success = false;
 
-        const { Rule } = ontology,
+        const { Rule } = elements,
               rule = Rule.fromRuleNode(ruleNode, context),
               ruleVerifies = rule.verify();
 
@@ -214,7 +214,7 @@ class TopLevelPass extends Pass {
       run: (axiomNode, context) => {
         let success = false;
 
-        const { Axiom } = ontology,
+        const { Axiom } = elements,
               axiom = Axiom.fromAxiomNode(axiomNode, context),
               axiomVerifies = axiom.verify();
 
@@ -230,7 +230,7 @@ class TopLevelPass extends Pass {
       run: (lemmaNode, context) => {
         let success = false;
 
-        const { Lemma } = ontology,
+        const { Lemma } = elements,
               lemma = Lemma.fromLemmaNode(lemmaNode, context),
               lemmaVerifies = lemma.verify();
 
@@ -246,7 +246,7 @@ class TopLevelPass extends Pass {
       run: (sectionNode, context) => {
         let success = false;
 
-        const { Section } = ontology,
+        const { Section } = elements,
               section = Section.fromSectionNode(sectionNode, context),
               sectionVerifies = section.verify();
 
@@ -262,7 +262,7 @@ class TopLevelPass extends Pass {
       run: (theoremNode, context) => {
         let success = false;
 
-        const { Theorem } = ontology,
+        const { Theorem } = elements,
               theorem = Theorem.fromTheoremNode(theoremNode, context),
               theoremVerifies = theorem.verify();
 
@@ -278,7 +278,7 @@ class TopLevelPass extends Pass {
       run: (metaLemmaNode, context) => {
         let success = false;
 
-        const { MetaLemma } = ontology,
+        const { MetaLemma } = elements,
               metaLemma = MetaLemma.fromMetaLemmaNode(metaLemmaNode, context),
               metaLemmaVerifies = metaLemma.verify();
 
@@ -294,7 +294,7 @@ class TopLevelPass extends Pass {
       run: (conjectureNode, context) => {
         let success = false;
 
-        const { Conjecture } = ontology,
+        const { Conjecture } = elements,
               conjecture = Conjecture.fromConjectureNode(conjectureNode, context),
               conjectureVerifies = conjecture.verify();
 
@@ -310,7 +310,7 @@ class TopLevelPass extends Pass {
       run: (metatheoremNode, context) => {
         let success = false;
 
-        const { Metatheorem } = ontology,
+        const { Metatheorem } = elements,
               metatheorem = Metatheorem.fromMetatheoremNode(metatheoremNode, context),
               metatheoremVerifies = metatheorem.verify();
 
@@ -326,7 +326,7 @@ class TopLevelPass extends Pass {
       run: (variableDeclarationNode, context) => {
         let success = false;
 
-        const { VariableDeclaration } = ontology,
+        const { VariableDeclaration } = elements,
               variableDeclaration = VariableDeclaration.fromVariableDeclarationNode(variableDeclarationNode, context),
               variableDeclarationVerifies = variableDeclaration.verify();
 
@@ -342,7 +342,7 @@ class TopLevelPass extends Pass {
       run: (simpleTypeDeclarationNode, context) => {
         let success = false;
 
-        const { SimpleTypeDeclaration } = ontology,
+        const { SimpleTypeDeclaration } = elements,
               simpleTypeDeclaration = SimpleTypeDeclaration.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
               simpleTypeDeclarationVerifies = simpleTypeDeclaration.verify();
 
@@ -358,7 +358,7 @@ class TopLevelPass extends Pass {
       run: (typePrefixDeclarationNode, context) => {
         let success = false;
 
-        const { TypePrefixDeclaration } = ontology,
+        const { TypePrefixDeclaration } = elements,
               typePrefixDeclaration = TypePrefixDeclaration.fromTypePrefixDeclarationNode(typePrefixDeclarationNode, context),
               typePrefixDeclarationVerifies = typePrefixDeclaration.verify();
 
@@ -374,7 +374,7 @@ class TopLevelPass extends Pass {
       run: (combinatorDeclarationNode, context) => {
         let success = false;
 
-        const { CombinatorDeclaration } = ontology,
+        const { CombinatorDeclaration } = elements,
               combinatorDeclaration = CombinatorDeclaration.fromCombinatorDeclarationNode(combinatorDeclarationNode, context),
               combinatorDeclarationVerifies = combinatorDeclaration.verify();
 
@@ -390,7 +390,7 @@ class TopLevelPass extends Pass {
       run: (constructorDeclarationNode, context) => {
         let success = false;
 
-        const { ConstructorDeclaration } = ontology,
+        const { ConstructorDeclaration } = elements,
               constructorDeclaration = ConstructorDeclaration.fromConstructorDeclarationNode(constructorDeclarationNode, context),
               constructorDeclarationVerifies = constructorDeclaration.verify();
 
@@ -406,7 +406,7 @@ class TopLevelPass extends Pass {
       run: (complexTypeDeclarationNode, context) => {
         let success = false;
 
-        const { ComplexTypeDeclaration } = ontology,
+        const { ComplexTypeDeclaration } = elements,
               complexTypeDeclaration = ComplexTypeDeclaration.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
               complexTypeDeclarationVerifies = complexTypeDeclaration.verify();
 
@@ -422,7 +422,7 @@ class TopLevelPass extends Pass {
       run: (metavariableDeclarationNode, context) => {
         let success = false;
 
-        const { MetavariableDeclaration } = ontology,
+        const { MetavariableDeclaration } = elements,
               metavariableDeclaration = MetavariableDeclaration.fromMetavariableDeclarationNode(metavariableDeclarationNode, context),
               metavariableDeclarationVerifies = metavariableDeclaration.verify();
 
@@ -457,7 +457,7 @@ class CombinatorPass extends Pass {
       run: (statementNode, context) => {
         let success = false;
 
-        const { Statement } = ontology,
+        const { Statement } = elements,
               statement = Statement.fromStatementNode(statementNode, context),
               assignments = null,
               stated = false,
@@ -475,7 +475,7 @@ class CombinatorPass extends Pass {
       run: (termNode, context) => {
         let success = false;
 
-        const { Term } = ontology,
+        const { Term } = elements,
               term = Term.fromTermNode(termNode, context),
               termVerifies = term.verify(context, () => {
                 const verifiesAhead = true;
@@ -529,7 +529,7 @@ class ConstructorPass extends Pass {
       run: (termNode, context, verifyAhead) => {
         let success = false;
 
-        const { Term } = ontology,
+        const { Term } = elements,
               term = Term.fromTermNode(termNode, context),
               termVerifies = term.verify(context, verifyAhead);