occam-verify-cli 0.0.1073 → 0.0.1075

package/src/theorem.js

@@ -1,12 +1,7 @@
 "use strict";
 
 import shim from "./shim";
-import Label from "./label";
-import Proof from "./proof";
-import Consequent from "./consequent";
-import Supposition from "./supposition";
 import LocalContext from "./context/local";
-import Substitutions from "./substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
 import { stringFromLabels } from "./topLevelAssertion";
@@ -25,15 +20,15 @@ class Theorem extends TopLevelAssertion {
 
     this.fileContext.trace(`Verifying the '${theoremString}' theorem...`);
 
-    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
-      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
+      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
 
-      if (labelVVerifiedAtTopLevel) {
+      if (labelVVerifiedWhenDeclared) {
         return true;
       }
     });
 
-    if (labelsVerifiedAtTopLevel) {
+    if (labelsVerifiedWhenDeclared) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             suppositionsVerified = this.suppositions.every((supposition) => {
               const suppositionVerified = supposition.verify(localContext);
@@ -47,7 +42,8 @@ class Theorem extends TopLevelAssertion {
         const consequentVerified = this.consequent.verify(localContext);
 
         if (consequentVerified) {
-          const substitutions = Substitutions.fromNothing(),
+          const { Substitutions } = shim,
+                substitutions = Substitutions.fromNothing(),
                 proofVerified = this.proof.verify(substitutions, this.consequent, localContext);
 
           if (proofVerified) {
@@ -71,7 +67,8 @@ class Theorem extends TopLevelAssertion {
   static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Theorem, json, fileContext); }
 
   static fromTheoremNode(theoremNode, fileContext) {
-    const proofNode = proofNodeQuery(theoremNode),
+    const { Label, Proof, Consequent, Supposition } = shim,
+          proofNode = proofNodeQuery(theoremNode),
           labelNodes = labelNodesQuery(theoremNode),
           consequentNode = consequentNodeQuery(theoremNode),
           suppositionNodes = suppositionNodesQuery(theoremNode),

package/src/topLevelAssertion.js

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-import Substitutions from "./substitutions";
+import shim from "./shim";
 
 import { EMPTY_STRING } from "./constants";
 import { labelsFromJSON,
@@ -63,7 +63,8 @@ export default class TopLevelAssertion {
   unifyStatement(statement, localContext) {
     let statementUnified = false;
 
-    const proofSteps = localContext.getProofSteps(),
+    const { Substitutions } = shim,
+          proofSteps = localContext.getProofSteps(),
           substitutions = Substitutions.fromNothing(),
           proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
 

package/src/type.js

@@ -36,37 +36,24 @@ class Type {
   }
 
   isSubTypeOf(type) {
-    let subTypeOf = false;
-
-    let superType = this.superType;
-
-    while (superType !== null) {
-      if (superType === type) {
-        subTypeOf = true;
-
-        break;
-      }
-
-      superType = superType.getSuperType();
+    let subTypeOf;
+
+    if (false) {
+      ///
+    } else if (this === objectType) {
+      subTypeOf = false;
+    } else if (this.superType === type) {
+      subTypeOf = true;
+    } else {
+      subTypeOf = this.superType.isSubTypeOf(type);
     }
 
     return subTypeOf;
   }
 
   isSuperTypeOf(type) {
-    let superTypeOf = false;
-
-    let superType = type.getSuperType();
-
-    while (superType !== null) {
-      if (superType === this) {
-        superTypeOf = true;
-
-        break;
-      }
-
-      superType = superType.getSuperType();
-    }
+    const subTypeOf = type.isSubTypeOf(this),
+          superTypeOf = subTypeOf;  ///
 
     return superTypeOf;
   }
@@ -122,12 +109,12 @@ class Type {
     return typeNodeMatches;
   }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel = false;
 
     const typeString = this.string; ///
 
-    fileContext.trace(`Verifying the '${typeString}' type at top level...`);
+    fileContext.trace(`Verifying the '${typeString}' type when declared...`);
 
     const typePresent = fileContext.isTypePresentByTypeName(this.name);
 
@@ -149,7 +136,7 @@ class Type {
     }
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${typeString}' type at top level.`);
+      fileContext.debug(`...verified the '${typeString}' type when declared.`);
     }
 
     return verifiedAtTopLevel;

package/src/unifier/equality.js

@@ -5,7 +5,7 @@ import Unifier from "../unifier";
 import { nodeQuery } from "../utilities/query";
 import { findEquivalenceByTermNodes } from "../utilities/equivalences";
 
-const termNodeQuery = nodeQuery("/term!");
+const termNodeQuery = nodeQuery("/term");
 
 class EqualityUnifier extends Unifier {
   unify(leftTermNode, rightTermNode, localContext) {

package/src/unifier/metaLevel.js

@@ -6,11 +6,11 @@ import TermForVariableSubstitution from "../substitution/termForVariable";
 import FrameForMetavariableSubstitution from "../substitution/frameForMetavariable";
 
 import { nodeQuery } from "../utilities/query";
-import { variableNameFromVariableNode, metavariableNameFromMetavariableNode } from "../utilities/name";
+import { variableNameFromVariableNode } from "../utilities/name";
 
-const termNodeQuery = nodeQuery("/term!"),
-      frameNodeQuery = nodeQuery("/frame!"),
-      statementNodeQuery = nodeQuery("/statement!"),
+const termNodeQuery = nodeQuery("/term"),
+      frameNodeQuery = nodeQuery("/frame"),
+      statementNodeQuery = nodeQuery("/statement"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
@@ -56,8 +56,7 @@ class MetaLevelUnifier extends Unifier {
 
             const { Statement } = shim,
                   metavariableNode = statementMetavariableNode, ///
-                  metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-                  metavariable = localContextA.findMetavariableByMetavariableName(metavariableName);
+                  metavariable = localContextA.findMetavariableByMetavariableNode(metavariableNode, localContextB);
 
             localContext = localContextB; ///
 
@@ -67,7 +66,7 @@ class MetaLevelUnifier extends Unifier {
 
             statementUnified = metavariable.unifyStatement(statement, substitution, substitutions, localContext);
           } else {
-            statementUnified = unifyStatementWithStatement(statementNodeA, statementNodeB, substitutions, localContextA, localContextB);
+            statementUnified = unifyChildNodes(statementNodeA, statementNodeB, substitutions, localContextA, localContextB);
           }
         }
 
@@ -81,8 +80,7 @@ class MetaLevelUnifier extends Unifier {
         let frameUnified = false;
 
         const metavariableNode = frameMetavariableNodeA,  ///
-              metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-              metavariablePresent = localContextA.isMetavariablePresentByMetavariableName(metavariableName);
+              metavariablePresent = localContextA.isMetavariablePresentByMetavariableNode(metavariableNode, localContextB);
 
         if (metavariablePresent) {
           const { Frame, Metavariable } = shim,
@@ -127,7 +125,7 @@ const metaLevelUnifier = new MetaLevelUnifier();
 
 export default metaLevelUnifier;
 
-function unifyStatementWithStatement(statementNodeA, statementNodeB, substitutions, localContextA, localContextB) {
+function unifyChildNodes(statementNodeA, statementNodeB, substitutions, localContextA, localContextB) {
   const nonTerminalNodeA = statementNodeA, ///
         nonTerminalNodeB = statementNodeB, ///
         nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),

package/src/unifier/metavariable.js

@@ -6,8 +6,8 @@ import Unifier from "../unifier";
 import { nodeQuery } from "../utilities/query";
 import { typeNameFromTypeNode } from "../utilities/name";
 
-const typeNodeQuery = nodeQuery("/type!"),
-      termNodeQuery = nodeQuery("/term!");
+const typeNodeQuery = nodeQuery("/type"),
+      termNodeQuery = nodeQuery("/term");
 
 class MetavariableUnifier extends Unifier {
   unify(metavariableNodeA, metavariableNodeB, localContext) {
@@ -27,7 +27,7 @@ class MetavariableUnifier extends Unifier {
       nodeQueryA: typeNodeQuery,
       nodeQueryB: termNodeQuery,
       unify: (typeNodeA, termNodeB, localContext) => {
-        let unified = false;
+        let termUnified = false;
 
         const { Term } = shim,
               typeNode = typeNodeA, ///
@@ -40,11 +40,11 @@ class MetavariableUnifier extends Unifier {
                 termVerifiedGivenType = term.verifyGivenType(type, localContext);
 
           if (termVerifiedGivenType) {
-            unified = true;
+            termUnified = true;
           }
         }
 
-        return unified;
+        return termUnified;
       }
     }
   ];

package/src/unifier/statementWithCombinator.js

@@ -6,11 +6,11 @@ import Unifier from "../unifier";
 import { nodeQuery } from "../utilities/query";
 import { typeNameFromTypeNode } from "../utilities/name";
 
-const termNodeQuery = nodeQuery("/term!"),
-      typeNodeQuery = nodeQuery("/type!"),
-      frameNodeQuery = nodeQuery("/frame!"),
-      metaTypeNodeQuery = nodeQuery("/metaType!"),
-      statementNodeQuery = nodeQuery("/statement!");
+const termNodeQuery = nodeQuery("/term"),
+      typeNodeQuery = nodeQuery("/type"),
+      frameNodeQuery = nodeQuery("/frame"),
+      metaTypeNodeQuery = nodeQuery("/metaType"),
+      statementNodeQuery = nodeQuery("/statement");
 
 class StatementWithCombinatorUnifier extends Unifier {
   unify(combinatorStatementNode, statementNode, assignments, stated, localContext) {

package/src/utilities/brackets.js

@@ -5,8 +5,8 @@ import { bracketedTermNode } from "../constructor/bracketed";
 import { bracketedStatementNode } from "../combinator/bracketed";
 import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
 
-const bracketedTermChildNodeQuery = nodeQuery("/term/argument/term!"),
-      bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument/statement!");
+const bracketedTermChildNodeQuery = nodeQuery("/term/argument/term"),
+      bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument/statement");
 
 export function stripBracketsFromTermNode(termNode) {
   const bracketedTermChildNode = bracketedTermChildNodeFromTermNode(termNode);

package/src/utilities/equivalences.js

@@ -6,9 +6,9 @@ import Equivalence from "../equivalence";
 
 const { push, compress, separate } = arrayUtilities;
 
-export function mergeEquivalences(equivalencesA, equivalencesB, localContext) {
-  const typesA = typesFromEquivalences(equivalencesA, localContext),
-        typesB = typesFromEquivalences(equivalencesB, localContext),
+export function mergeEquivalences(equivalencesA, equivalencesB) {
+  const typesA = typesFromEquivalences(equivalencesA),
+        typesB = typesFromEquivalences(equivalencesB),
         types = [
           ...typesA,
           ...typesB
@@ -23,8 +23,8 @@ export function mergeEquivalences(equivalencesA, equivalencesB, localContext) {
   const equivalences = types.map((type) => {
     let equivalence;
 
-    const equivalenceA = findEquivalenceByType(equivalencesA, type, localContext),
-          equivalenceB = findEquivalenceByType(equivalencesB, type, localContext);
+    const equivalenceA = findEquivalenceByType(equivalencesA, type),
+          equivalenceB = findEquivalenceByType(equivalencesB, type);
 
     if ((equivalenceA !== null) && (equivalenceB !== null)) {
       const leftEquivalence = equivalenceA, ///
@@ -43,9 +43,9 @@ export function mergeEquivalences(equivalencesA, equivalencesB, localContext) {
   return equivalences;
 }
 
-export function findEquivalenceByType(equivalences, type, localContext) {
+export function findEquivalenceByType(equivalences, type) {
   const equivalence = equivalences.find((equivalence) => {
-    const equivalenceMatchesType = equivalence.matchType(type, localContext);
+    const equivalenceMatchesType = equivalence.matchType(type);
 
     if (equivalenceMatchesType) {
       return true;
@@ -127,9 +127,9 @@ export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalence
   }
 }
 
-function typesFromEquivalences(equivalences, localContext) {
+function typesFromEquivalences(equivalences) {
   const types = equivalences.map((equivalence) => {
-    const type = equivalence.getType(localContext);
+    const type = equivalence.getType();
 
     return type;
   });

package/src/utilities/node.js

@@ -1,23 +1,14 @@
 "use strict";
 
-import { parsersUtilities } from "occam-custom-grammars";
-
 import { nodeQuery } from "../utilities/query";
-import { combinedCustomGrammarFromNothing } from "./customGrammar";
 import { VARIABLE_RULE_NAME,
          METAVARIABLE_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
 import { variableTokensFromVariableString,
          metavariableTokensFromMetavariableString,
-         unqualifiedStatementTokensFromUnqualifiedStatementString,
          constructorDeclarationTokensFromConstructorDeclarationString } from "../utilities/tokens";
 
-const { nominalParserFromCombinedCustomGrammar } = parsersUtilities;
-
-const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
-      nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar);
-
 const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement"),
       substitutionNodeQuery = nodeQuery("/unqualifiedStatement/statement/substitution");
@@ -114,7 +105,7 @@ export function constructorDeclarationNodeFromConstructorDeclarationTokens(const
   return constructorDeclarationNode;
 }
 
-function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser = nominalParser) {
+function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser) {
   const ruleMap = parser.getRuleMap(),
         rule = ruleMap[ruleName],
         node = parser.parse(tokens, rule);

package/src/utilities/nominal.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
+
+import { combinedCustomGrammarFromNothing } from "./customGrammar";
+
+const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
+      { nominalParserFromCombinedCustomGrammar } = parsersUtilities;
+
+const combinedCustomGrammar = combinedCustomGrammarFromNothing();
+
+export const nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+
+export const nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar);

package/src/utilities/subproof.js

@@ -3,8 +3,8 @@
 import { nodeQuery, nodesQuery } from "./query";
 import { nodeAsString, nodesAsString } from "./string";
 
-const subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
-      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
+const subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement");
 
 export function subproofStringFromSubproofNode(subproofNode, fileContext) {
   const tokens = fileContext.getTokens(),

package/src/utilities/tokens.js

@@ -1,15 +1,8 @@
 "use strict";
 
 import { arrayUtilities } from "necessary";
-import { lexersUtilities } from "occam-custom-grammars";
 
-import { combinedCustomGrammarFromNothing } from "./customGrammar";
-
-const { front } = arrayUtilities,
-      { nominalLexerFromCombinedCustomGrammar } = lexersUtilities;
-
-const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
-      nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+const { front } = arrayUtilities;
 
 export function variableTokensFromVariableString(variableString, lexer) {
   const variableContent = `${variableString}`,
@@ -63,7 +56,7 @@ export function substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionN
   return substitutionTokens;
 }
 
-function tokensFromContentAndLexer(content, lexer = nominalLexer) {
+function tokensFromContentAndLexer(content, lexer) {
   const tokens = lexer.tokenise(content);
 
   return tokens;

package/src/variable.js

@@ -70,14 +70,14 @@ class Variable {
           variableName = variableNameFromVariableNode(variableNode),
           variable = localContext.findVariableByVariableName(variableName);
 
-    if (variable === null) {
-      localContext.debug(`The '${variableString}' variable is not present.`);
-    } else {
+    if (variable !== null) {
       const type = variable.getType();
 
       this.type = type;
 
       verified = true;
+    } else {
+      localContext.debug(`The '${variableString}' variable is not present.`);
     }
 
     if (verified) {
@@ -115,12 +115,12 @@ class Variable {
     return typeVerified;
   }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel;
 
     const variableString = this.string; ///
 
-    fileContext.trace(`Verifying the '${variableString}' variable at top level...`);
+    fileContext.trace(`Verifying the '${variableString}' variable when declared...`);
 
     const variableNode = this.node, ///
           variableName = variableNameFromVariableNode(variableNode),
@@ -135,7 +135,7 @@ class Variable {
     }
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${variableString}' variable at top level.`);
+      fileContext.debug(`...verified the '${variableString}' variable when declared.`);
     }
 
     return verifiedAtTopLevel;
@@ -248,11 +248,16 @@ class Variable {
   }
 
   static fromVariableNodeAndType(variableNode, type, localContext) {
-    const node = variableNode,  ///
-          variableName = variableNameFromVariableNode(variableNode),
-          string = localContext.nodeAsString(node),
-          name = variableName,  ///
-          variable = new Variable(localContext, string, node, name, type);
+    let variable = null;
+
+    if (variableNode !== null) {
+      const node = variableNode,  ///
+            variableName = variableNameFromVariableNode(variableNode),
+            string = localContext.nodeAsString(node),
+            name = variableName;  ///
+
+      variable = new Variable(localContext, string, node, name, type);
+    }
 
     return variable;
   }

package/src/verifier/metaLevel.js

@@ -5,8 +5,8 @@ import Verifier from "../verifier";
 
 import { nodeQuery } from "../utilities/query";
 
-const termNodeQuery = nodeQuery("/term!"),
-      statementNodeQuery = nodeQuery("/statement!");
+const termNodeQuery = nodeQuery("/term"),
+      statementNodeQuery = nodeQuery("/statement");
 
 class MetaLevelVerifier extends Verifier {
   verify(node, assignments, stated, localContext) {

package/src/verifier/statementAsCombinator.js

@@ -7,9 +7,9 @@ import LocalContext from "../context/local";
 import { nodeQuery } from "../utilities/query";
 import { typeNameFromTypeNode } from "../utilities/name";
 
-const termNodeQuery = nodeQuery("/term!"),
-      typeNodeQuery = nodeQuery("/type!"),
-      statementNodeQuery = nodeQuery("/statement!");
+const termNodeQuery = nodeQuery("/term"),
+      typeNodeQuery = nodeQuery("/type"),
+      statementNodeQuery = nodeQuery("/statement");
 
 class StatementAsCombinatorVerifier extends Verifier {
   verifyStatement(statementNode, fileContext) {

package/src/verifier/termAsConstructor.js

@@ -7,8 +7,8 @@ import LocalContext from "../context/local";
 import { nodeQuery } from "../utilities/query";
 import {typeNameFromTypeNode} from "../utilities/name";
 
-const termNodeQuery = nodeQuery("/term!"),
-      typeNodeQuery = nodeQuery("/type!");
+const termNodeQuery = nodeQuery("/term"),
+      typeNodeQuery = nodeQuery("/type");
 
 class TermAsConstructorVerifier extends Verifier {
   verifyTerm(termNode, fileContext) {

package/src/verifier/topLevel.js

@@ -1,13 +1,7 @@
 "use strict";
 
-import Rule from "../rule";
+import shim from "../shim";
 import Error from "../error";
-import Axiom from "../axiom";
-import Lemma from "../lemma";
-import Theorem from "../theorem";
-import MetaLemma from "../metaLemma";
-import Conjecture from "../conjecture";
-import Metatheorem from "../metatheorem";
 import TypeDeclaration from "../declaration/type";
 import VariableDeclaration from "../declaration/variable";
 import CombinatorDeclaration from "../declaration/combinator";
@@ -57,7 +51,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: ruleNodeQuery,
       verify: (ruleNode, fileContext) => {
-        const rule = Rule.fromRuleNode(ruleNode, fileContext),
+        const { Rule } = shim,
+              rule = Rule.fromRuleNode(ruleNode, fileContext),
               ruleVerified = rule.verify();
 
         return ruleVerified;
@@ -66,7 +61,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: axiomNodeQuery,
       verify: (axiomNode, fileContext) => {
-        const axiom = Axiom.fromAxiomNode(axiomNode, fileContext),
+        const { Axiom } = shim,
+              axiom = Axiom.fromAxiomNode(axiomNode, fileContext),
               axiomVerified = axiom.verify();
 
         return axiomVerified;
@@ -75,7 +71,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: lemmaNodeQuery,
       verify: (lemmaNode, fileContext) => {
-        const lemma = Lemma.fromLemmaNode(lemmaNode, fileContext),
+        const { Lemma } = shim,
+              lemma = Lemma.fromLemmaNode(lemmaNode, fileContext),
               lemmaVerified = lemma.verify();
 
         return lemmaVerified;
@@ -84,7 +81,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: theoremNodeQuery,
       verify: (theoremNode, fileContext) => {
-        const theorem = Theorem.fromTheoremNode(theoremNode, fileContext),
+        const { Theorem } = shim,
+              theorem = Theorem.fromTheoremNode(theoremNode, fileContext),
               theoremVerified = theorem.verify();
 
         return theoremVerified;
@@ -93,7 +91,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: metaLemmaNodeQuery,
       verify: (metaLemmaNode, fileContext) => {
-        const metaLemma = MetaLemma.fromMetaLemmaNode(metaLemmaNode, fileContext),
+        const { MetaLemma } = shim,
+              metaLemma = MetaLemma.fromMetaLemmaNode(metaLemmaNode, fileContext),
               metaLemmaVerified = metaLemma.verify();
 
         return metaLemmaVerified;
@@ -102,7 +101,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: conjectureNodeQuery,
       verify: (conjectureNode, fileContext) => {
-        const conjecture = Conjecture.fromConjectureNode(conjectureNode, fileContext),
+        const { Conjecture } = shim,
+              conjecture = Conjecture.fromConjectureNode(conjectureNode, fileContext),
               conjectureVerified = conjecture.verify();
 
         return conjectureVerified;
@@ -111,7 +111,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: metatheoremNodeQuery,
       verify: (metatheoremNode, fileContext) => {
-        const metatheorem = Metatheorem.fromMetatheoremNode(metatheoremNode, fileContext),
+        const { Metatheorem } = shim,
+              metatheorem = Metatheorem.fromMetatheoremNode(metatheoremNode, fileContext),
               metatheoremVerified = metatheorem.verify();
 
         return metatheoremVerified;