occam-verify-cli 0.0.1067 → 0.0.1069

package/src/metavariable.js

@@ -1,18 +1,21 @@
 "use strict";
 
 import shim from "./shim";
-import Argument from "./argument";
 import LocalContext from "./context/local";
 import metavariableUnifier from "./unifier/metavariable";
+import FrameForMetavariableSubstitution from "./substitution/frameForMetavariable";
 import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
 import { nodeQuery } from "./utilities/query";
-import { metavariableNameFromMetavariableNode } from "./utilities/name";
 import { metavariableNodeFromMetavariableString } from "./utilities/node";
+import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "./utilities/json";
+import { typeNameFromTypeNode, metavariableNameFromMetavariableNode } from "./utilities/name";
 
-const argumentNodeQuery = nodeQuery("/metavariable/argument"),
+const termNodeQuery = nodeQuery("/metavariable/argument/term"),
+      typeNodeQuery = nodeQuery("/metavariable/argument/type"),
       metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType"),
       metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
+      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 class Metavariable {
@@ -50,6 +53,12 @@ class Metavariable {
     return metaTypeName;
   }
 
+  matchMetaType(metaType) {
+    const metaTypeMatches = (this.metaType === metaType);
+
+    return metaTypeMatches;
+  }
+
   matchMetavariableName(metavariableName) {
     const metavariableNameMatches = (this.name === metavariableName);
 
@@ -62,6 +71,131 @@ class Metavariable {
     return metavariableNodeMatches;
   }
 
+  unifyFrame(frame, substitutions, localContext) {
+    let frameUnified = false;
+
+    const frameNode = frame.getNode(),
+          frameString = frame.getString(),
+          metavariableString = this.string; ///
+
+    localContext.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
+
+    const metavariableName = this.name, ///
+          simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariableName(metavariableName);
+
+    if (simpleSubstitutionPresent) {
+      const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableName(metavariableName),
+            substitution = simpleSubstitution,  ///
+            frameNodeMatches = substitution.matchFrameNode(frameNode);
+
+      if (frameNodeMatches) {
+        frameUnified = true;
+      }
+    } else {
+      const metavariableNode = this.node,  ///
+            metavariable = metavariableFromMetavariableNode(metavariableNode, localContext),
+            frameMetavariable  = frameMetavariableFromStatementNode(frameNode, localContext);
+
+      if (metavariable === frameMetavariable) {
+        frameUnified = true;
+      } else {
+        const metavariable = this,  ///
+              frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromFrameAndMetavariable(frame, metavariable, localContext),
+              substitution = frameForMetavariableSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, localContext);
+
+        frameUnified = true;
+      }
+    }
+
+    if (frameUnified) {
+      localContext.debug(`...unified the '${frameString}' frame with the '${metavariableString}' metavariable.`);
+    }
+
+    return frameUnified;
+  }
+
+  unifyStatement(statement, substitution, substitutions, localContext) {
+    let statementUnified = false;
+
+    const statementString = statement.getString(),
+          metavariableString = this.string, ///
+          substitutionString = (substitution !== null) ?
+                                  substitution.getString() :
+                                    null;
+
+    (substitutionString !== null) ?
+      localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable given the ${substitutionString} substitution...`) :
+        localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable...`);
+
+    const statementNode = statement.getNode(),
+          metavariableNode = this.node, ///
+          metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+          substitutionNode = (substitution !== null) ?
+                                substitution.getSubstitutionNode() :
+                                  null,
+          substitutionPresent = substitutions.isSubstitutionPresentByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode);
+
+    if (substitutionPresent) {
+      const substitution = substitutions.findSubstitutionByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode),
+            statementNodeMatches = substitution.matchStatementNode(statementNode);
+
+      if (statementNodeMatches) {
+        statementUnified = true;
+      }
+    } else {
+      const metavariableNode = this.node,  ///
+            metavariable = metavariableFromMetavariableNode(metavariableNode, localContext),
+            statementMetavariable = statementMetavariableFromStatementNode(statementNode, localContext);
+
+      if (metavariable === statementMetavariable) {
+        statementUnified = true;
+      } else {
+        const metavariable = this,  ///
+              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
+
+        substitution = statementForMetavariableSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, localContext);
+
+        statementUnified = true;
+      }
+    }
+
+    if (statementUnified) {
+      (substitutionString !== null) ?
+        localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable given the ${substitutionString} substitution.`) :
+          localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable.`);
+    }
+
+    return statementUnified;
+  }
+
+  unifySubstitution(substitution, localContext) {
+    let substitutionUnified = false;
+
+    const metavariableString = this.string,  ///
+          substitutionString = substitution.getString();
+
+    localContext.trace(`Unifying the '${substitutionString}' substitution with the '${metavariableString}' metavariable...`);
+
+    const metavariableName = this.name, ///
+          judgement = localContext.findJudgementByMetavariableName(metavariableName);
+
+    if (judgement !== null){
+      const declaration = judgement.getDeclaration();
+
+      substitutionUnified = declaration.unifySubstitution(substitution, localContext);
+    }
+
+    if (substitutionUnified) {
+      localContext.debug(`...unified the '${substitutionString}' substitution with the '${metavariableString}' metavariable.`);
+    }
+
+    return substitutionUnified;
+  }
+
   verify(localContext) {
     let verified;
 
@@ -80,7 +214,6 @@ class Metavariable {
             metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
 
       verified = metavariableUnified; ///
-
     }
 
     if (verified) {
@@ -104,15 +237,25 @@ class Metavariable {
     if (metavariablePresent) {
       fileContext.debug(`The metavariable '${metavariableString}' is already present.`);
     } else {
-      const argumentNode = argumentNodeQuery(metavariableNode),
-            argument = Argument.fromArgumentNode(argumentNode, fileContext);
+      const termNode = termNodeQuery(this.node);
 
-      if (argument === null) {
-        verifiedAtTopLevel = true;
-      } else {
-        const argumentVerified = argument.verify(fileContext);
+      if (termNode !== null) {
+        const termString = this.fileContext.nodeAsString(termNode);
 
-        if (argumentVerified) {
+        this.fileContext.debug(`The '${termString}' term was found when a type should have been present.`);
+      } else {
+        const typeNode = typeNodeQuery(this.node);
+
+        if (typeNode !== null) {
+          const typeName = typeNameFromTypeNode(typeNode),
+                typePresent = this.fileContext.isTypePresentByTypeName(typeName);
+
+          if (typePresent) {
+            verifiedAtTopLevel = true;
+          } else {
+            this.fileContext.debug(`The '${typeName}' type is not present.`);
+          }
+        } else {
           verifiedAtTopLevel = true;
         }
       }
@@ -125,63 +268,35 @@ class Metavariable {
     return verifiedAtTopLevel;
   }
 
-  unifyStatement(statement, substitution, substitutions, localContext) {
-    let statementUnified = false;
+  verifyGivenMetaType(metaType, localContext) {
+    let verifiedGivenMetaType = false;
 
-    const statementString = statement.getString(),
-          metavariableString = this.string, ///
-          substitutionString = (substitution !== null) ?
-                                  substitution.getString() :
-                                    null;
+    const metavariableString = this.string,  ///
+          metaTypeString = metaType.getString();
 
-    (substitutionString !== null) ?
-      localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable given the ${substitutionString} substitution...`) :
-        localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable...`);
+    localContext.trace(`Verifying the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type...`);
 
-    const statementNode = statement.getNode(),
-          metavariableNode = this.node, ///
-          substitutionNode = (substitution !== null) ?
-                               substitution.getSubstitutionNode() :
-                                 null,
-          substitutionPresent = substitutions.isSubstitutionPresentByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
-
-    if (substitutionPresent) {
-      const substitution = substitutions.findSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode),
-            statementNodeMatches = substitution.matchStatementNode(statementNode);
-
-      if (statementNodeMatches) {
-        statementUnified = true;
-      }
-    } else {
-      const metavariable = this, ///
-            statementMetavariable = statementMetavariableFromStatementNode(statementNode, localContext);
-
-      if (metavariable === statementMetavariable) {
-        statementUnified = true;
-      } else {
-        const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
-
-        substitution = statementForMetavariableSubstitution;  ///
+    const name = this.getName(),
+          metavariableName = name,  ///
+          metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
 
-        substitutions.addSubstitution(substitution, localContext);
+    if (metavariable !== null) {
+      const metaTypeMatches = metavariable.matchMetaType(metaType);
 
-        statementUnified = true;
-      }
+      verifiedGivenMetaType = metaTypeMatches;  ///
     }
 
-    (substitutionString !== null) ?
-      localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable given the ${substitutionString} substitution.`) :
-        localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable.`);
+    if (verifiedGivenMetaType) {
+      localContext.debug(`...verified the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type.`);
+    }
 
-    return statementUnified;
+    return verifiedGivenMetaType;
   }
 
   toJSON() {
-    const metaTypeJSON = (this.metaType !== null) ?
-                            this.metaType.toJSON() :
-                              null,
-          string = this.string,
+    const metaTypeJSON = metaTypeToMetaTypeJSON(this.metaType),
           metaType = metaTypeJSON,  ///
+          string = this.string,
           json = {
             string,
             metaType
@@ -205,17 +320,17 @@ class Metavariable {
     return metavariable;
   }
 
-  static fromMetavariableNode(metavariableNode, fileContext) {
+  static fromMetavariableNode(metavariableNode, localContext) {
     let metavariable = null;
 
     if (metavariableNode !== null) {
       const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
             node = metavariableNode,  ///
             name = metavariableName,  ///
-            string = fileContext.nodeAsString(node),
+            string = localContext.nodeAsString(node),
             metaType = null;
 
-      metavariable = new Metavariable(fileContext, string, node, name, metaType);
+      metavariable = new Metavariable(localContext, string, node, name, metaType);
     }
 
     return metavariable;
@@ -244,17 +359,25 @@ Object.assign(shim, {
 
 export default Metavariable;
 
-function metaTypeFromJSON(json, fileContext) {
-  let { metaType } = json;
+function metavariableFromMetavariableNode(metavariableNode, localContext) {
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+
+  return metavariable;
+}
+
+function frameMetavariableFromStatementNode(frameNode, localContext) {
+  let frameMetavariable = null;
+
+  const frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
 
-  if (metaType !== null) {
-    const { name } = metaType,
-          metaTypeName = name;  ///
+  if (frameMetavariableNode !== null) {
+    const frameMetavariableName = metavariableNameFromMetavariableNode(frameMetavariableNode);
 
-    metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName);
+    frameMetavariable = localContext.findMetavariableByMetavariableName(frameMetavariableName);
   }
 
-  return metaType;
+  return frameMetavariable;
 }
 
 function statementMetavariableFromStatementNode(statementNode, localContext) {

package/src/mixins/statement/qualified/unify.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import metavariableUnifier from "../../../unifier/metavariable";
 import StatementForMetavariableSubstitution from "../../../substitution/statementForMetavariable";
 
 import { trim } from "../../../utilities/string";
@@ -137,33 +136,22 @@ function unifyAWithReference(qualifiedStatement, substitutions, localContext) {
   const reference = qualifiedStatement.getReference(),
         metavariableNode = reference.getMetavariableNode(),
         metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+        metavariablePresent = localContext.isMetavariablePresentByMetavariableName(metavariableName);
 
-  if (metavariable !== null) {
+  if (metavariablePresent) {
     const statement = qualifiedStatement.getStatement(),
           statementString = statement.getString(),
           referenceString = reference.getString();
 
     localContext.trace(`Unifying the '${statementString}' qualified statement with the '${referenceString}' reference...`);
 
-    const metavariableNode = metavariable.getNode(),
-          referenceMetavariableNode = reference.getMetavariableNode(),
-          metavariableNodeA = referenceMetavariableNode, ///
-          metavariableNodeB = metavariableNode, ///
-          metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
+    const metavariable = reference.getMetavariable(),
+          statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, localContext),
+          substitution = statementForMetavariableSubstitution; ///
 
-    if (metavariableUnified) {
-      const statementNode = statement.getNode(),
-            metavariableNode = metavariableNodeA, ///
-            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeAndMetavariableNode(statementNode, metavariableNode, localContextA, localContextB),
-            substitution = statementForMetavariableSubstitution, ///
-            localContextA = localContext, ///
-            localContextB = localContext; ///
+    substitutions.addSubstitution(substitution, localContext);
 
-      substitutions.addSubstitution(substitution, localContextA, localContextB);
-
-      unifiedWithReference = true;
-    }
+    unifiedWithReference = true;
 
     if (unifiedWithReference) {
       localContext.debug(`...unified the '${statementString}' qualified statement with the '${referenceString}' reference.`);

package/src/mixins/statement/unify.js

@@ -1,12 +1,8 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import BracketedCombinator from "../../combinator/bracketed";
 import statementWithCombinatorUnifier from "../../unifier/statementWithCombinator";
 
-const { reverse } = arrayUtilities;
-
 function unifyWithBracketedCombinator(statement, assignments, stated, localContext) {
   let unifiedWithBracketedCombinator;
 
@@ -18,7 +14,7 @@ function unifyWithBracketedCombinator(statement, assignments, stated, localConte
 
   localContext.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`);
 
-  unifiedWithBracketedCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, assignments, stated, localContext);
+  unifiedWithBracketedCombinator = statementWithCombinatorUnifier.unify(combinatorStatementNode, statementNode, assignments, stated, localContext);
 
   if (unifiedWithBracketedCombinator) {
     localContext.debug(`...unified the '${statementString}' statement with the bracketed combinator.`);
@@ -47,28 +43,10 @@ function unifyWithCombinators(statement, assignments, stated, localContext) {
   return unifiedWithCombinators;
 }
 
-function unifyWithProofSteps(statement, assignments, stated, localContext) {
-  let unifiedWithProofSteps;
-
-  let proofSteps = localContext.getProofSteps();
-
-  proofSteps = reverse(proofSteps); ///
-
-  unifiedWithProofSteps = proofSteps.some((proofStep) => {
-    const statementUnified = proofStep.unifyStatement(statement, localContext);
-
-    if (statementUnified) {
-      return true;
-    }
-  });
-
-  return unifiedWithProofSteps;
-}
 
 const unifyMixins = [
   unifyWithBracketedCombinator,
-  unifyWithCombinators,
-  unifyWithProofSteps
+  unifyWithCombinators
 ];
 
 export default unifyMixins;
@@ -83,7 +61,7 @@ function unifyStatementWithCombinator(statement, combinator, assignments, stated
 
   localContext.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`);
 
-  unifiedWithCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, assignments, stated, localContext);
+  unifiedWithCombinator = statementWithCombinatorUnifier.unify(combinatorStatementNode, statementNode, assignments, stated, localContext);
 
   if (unifiedWithCombinator) {
     localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`);

package/src/mixins/statement/verify.js

@@ -1,16 +1,15 @@
 "use strict";
 
+import Frame from "../../frame";
 import Equality from "../../equality";
+import Judgement from "../../judgement";
+import Declaration from "../../declaration";
 import Metavariable from "../../metavariable";
 import TypeAssertion from "../../assertion/type";
 import DefinedAssertion from "../../assertion/defined";
 import SubproofAssertion from "../../assertion/subproof";
 import ContainedAssertion from "../../assertion/contained";
 
-import verifyFrame from "../../verify/frame";
-import verifyJudgement from "../../verify/judgement";
-import verifyDeclaration from "../../verify/declaration";
-
 import { nodeQuery } from "../../utilities/query";
 
 const frameNodeQuery = nodeQuery("/statement/frame!"),
@@ -75,14 +74,15 @@ function verifyAsFrame(statement, assignments, stated, localContext) {
   let verifiedAsFrame = false;
 
   const statementNode = statement.getNode(),
-        frameNode = frameNodeQuery(statementNode);
+        frameNode = frameNodeQuery(statementNode),
+        frame = Frame.fromFrameNode(frameNode, localContext);
 
-  if (frameNode !== null) {
+  if (frame !== null) {
     const statementString = statement.getString();
 
     localContext.trace(`Verifying the '${statementString}' statement as a frame...`);
 
-    const frameVerified = verifyFrame(frameNode, assignments, stated, localContext);
+    const frameVerified = frame.verify(assignments, stated, localContext);
 
     verifiedAsFrame = frameVerified; ///
 
@@ -98,14 +98,15 @@ function verifyAsJudgement(statement, assignments, stated, localContext) {
   let verifiedAsJudgement = false;
 
   const statementNode = statement.getNode(),
-        judgementNode = judgementNodeQuery(statementNode);
+        judgementNode = judgementNodeQuery(statementNode),
+        judgement = Judgement.fromJudgementNode(judgementNode, localContext);
 
-  if (judgementNode !== null) {
+  if (judgement !== null) {
     const statementString = statement.getString();
 
     localContext.trace(`Verifying the '${statementString}' statement as a judgement...`);
 
-    const judgementVerified = verifyJudgement(judgementNode, assignments, stated, localContext);
+    const judgementVerified = judgement.verify(assignments, stated, localContext);
 
     verifiedAsJudgement = judgementVerified;  ///
 
@@ -121,14 +122,15 @@ function verifyAsDeclaration(statement, assignments, stated, localContext) {
   let verifiedAsDeclaration = false;
 
   const statementNode = statement.getNode(),
-        declarationNode = declarationNodeQuery(statementNode);
+        declarationNode = declarationNodeQuery(statementNode),
+        declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
 
-  if (declarationNode !== null) {
+  if (declaration !== null) {
     const statementString = statement.getString();
 
     localContext.trace(`Verifying the '${statementString}' statement as a declaration...`);
 
-    const declarationVerified = verifyDeclaration(declarationNode, assignments, stated, localContext);
+    const declarationVerified = declaration.verify(assignments, stated, localContext);
 
     verifiedAsDeclaration = declarationVerified; ///
 

package/src/mixins/term/unify.js

@@ -87,7 +87,7 @@ function unifyTermWithConstructor(term, constructor, localContext, verifyAhead)
   const termNode = term.getNode(),
         constructorTerm = constructor.getTerm(),
         constructorTermNode = constructorTerm.getNode(),
-        unified = termWithConstructorUnifier.unify(termNode, constructorTermNode, localContext);
+        unified = termWithConstructorUnifier.unify(constructorTermNode, termNode, localContext);
 
   if (unified) {
     let verifiedAhead;

package/src/premise.js

@@ -7,10 +7,11 @@ import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
+import { unqualifiedStatementFromJSON, unqualifiedStatementToUnqualifiedStatementJSON } from "./utilities/json";
 
 const unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement");
 
-export default class Premise {
+class Premise {
   constructor(fileContext, unqualifiedStatement) {
     this.fileContext = fileContext;
     this.unqualifiedStatement = unqualifiedStatement;
@@ -40,7 +41,13 @@ export default class Premise {
 
     const statement = this.unqualifiedStatement.getStatement(),
           statementNode = statement.getNode(),
-          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, this.fileContext);
+          statementTokens = statement.getTokens(),
+          context = this.fileContext, ///
+          tokens = statementTokens; ///
+
+    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
+
+    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
 
     if (subproofAssertion !== null) {
       subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
@@ -61,12 +68,19 @@ export default class Premise {
 
     substitutions.snapshot();
 
+    let subproofUnified = false,
+        statementUnified = false;
+
     if (false) {
       ///
     } else if (subproof !== null) {
-      proofStepUnified = this.unifySubproof(subproof, substitutions, localContext);
+      subproofUnified = this.unifySubproof(subproof, substitutions, localContext);
     } else if (statement !== null) {
-      proofStepUnified = this.unifyStatement(statement, substitutions, localContext);
+      statementUnified = this.unifyStatement(statement, substitutions, localContext);
+    }
+
+    if (subproofUnified || statementUnified) {
+      proofStepUnified = true;
     }
 
     proofStepUnified ?
@@ -82,18 +96,18 @@ export default class Premise {
     const statementString = statement.getString(),
           premiseString = this.getString();
 
-    localContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
-
-    const localContextB = localContext;
+    const localContextB = localContext; ///
 
     localContext = LocalContext.fromFileContext(this.fileContext);
 
     const localContextA = localContext; ///
 
+    localContextB.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
+
     statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
+      localContextB.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
     }
 
     return statementUnified;
@@ -131,7 +145,7 @@ export default class Premise {
   }
 
   toJSON() {
-    const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
+    const unqualifiedStatementJSON = unqualifiedStatementToUnqualifiedStatementJSON(this.unqualifiedStatement),
           unqualifiedStatement = unqualifiedStatementJSON,  ///
           json = {
             unqualifiedStatement
@@ -141,13 +155,8 @@ export default class Premise {
   }
 
   static fromJSON(json, fileContext) {
-    let { unqualifiedStatement } = json;
-
-    json = unqualifiedStatement;  ///
-
-    unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
-
-    const premise = new Premise(fileContext, unqualifiedStatement);
+    const unqualifiedStatement = unqualifiedStatementFromJSON(json, fileContext),
+          premise = new Premise(fileContext, unqualifiedStatement);
 
     return premise;
   }
@@ -160,3 +169,9 @@ export default class Premise {
     return premise
   }
 }
+
+Object.assign(shim, {
+  Premise
+});
+
+export default Premise;