occam-verify-cli 0.0.698 → 0.0.700

package/src/type.js

@@ -58,29 +58,29 @@ export default class Type {
     return superTypeOf;
   }
 
-  isEqualToOrSubTypeOf(type) {
+  isComparableTo(type) {
     const equalTo = this.isEqualTo(type),
           subTypeOf = this.isSubTypeOf(type),
-          equalToOrSubTypeOf = (equalTo || subTypeOf);
+          superTypeOf = this.isSuperTypeOf(type),
+          comparableTo = equalTo || subTypeOf || superTypeOf;
 
-    return equalToOrSubTypeOf;
+    return comparableTo;
   }
 
-  isEqualToOrSuperTypeOf(type) {
+  isEqualToOrSubTypeOf(type) {
     const equalTo = this.isEqualTo(type),
-          superTypeOf = this.isSuperTypeOf(type),
-          equalToOrSuperTypeOf = (equalTo || superTypeOf);
+          subTypeOf = this.isSubTypeOf(type),
+          equalToOrSubTypeOf = equalTo || subTypeOf;
 
-    return equalToOrSuperTypeOf;
+    return equalToOrSubTypeOf;
   }
 
-  isEqualToSubTypeOfOrSuperTypeOf(type) {
+  isEqualToOrSuperTypeOf(type) {
     const equalTo = this.isEqualTo(type),
-          subTypeOf = this.isSubTypeOf(type),
           superTypeOf = this.isSuperTypeOf(type),
-          equalToOrSubTypeOfSuperTypeOf = (equalTo || subTypeOf || superTypeOf);
+          equalToOrSuperTypeOf = equalTo || superTypeOf;
 
-    return equalToOrSubTypeOfSuperTypeOf;
+    return equalToOrSuperTypeOf;
   }
 
   match(type) {
@@ -101,7 +101,7 @@ export default class Type {
     return typeNameMatches;
   }
 
-  asString(tokens, noSuperType) {
+  asString(tokens, noSuperType = false) {
     let string;
 
     if (noSuperType) {
@@ -135,22 +135,6 @@ export default class Type {
     return type;
   }
 
-  static fromJSONAndFileContext(json, fileContext) {
-    let type;
-
-    let { superType } = json;
-
-    const superTypeJSON = superType;  ///
-
-    superType = superTypeFromSuperTypeJSONAndFileContext(superTypeJSON, fileContext);
-
-    const { name } = json;
-
-    type = new Type(name, superType);
-
-    return type;
-  }
-
   static fromTypeNameAndSuperType(typeName, superType) {
     const name = typeName,  ///
           type = new Type(name, superType);
@@ -182,19 +166,23 @@ class ObjectType extends Type {
 
 export const objectType = ObjectType.fromNothing();
 
-function superTypeFromSuperTypeJSONAndFileContext(superTypeJSON, fileContext) {
-  let superType = null;
+export function typeFromJSONAndFileContext(json, fileContext) {
+  let type;
+
+  const { name } = json,
+        typeName = name;  ///
 
-  if (superTypeJSON !== null) {
-    const json = superTypeJSON, ///
-          { name } = json,
-          typeName = name,  ///
-          type = fileContext.findTypeByTypeName(typeName);
+  type = fileContext.findTypeByTypeName(typeName);
+
+  if (type === null) {
+    let { superType } = json;
 
-      superType = (type !== null) ?
-                    type :  ///
-                      Type.fromJSONAndFileContext(json, fileContext);  ///
+    const superJSON = superType;  ///
+
+    superType = typeFromJSONAndFileContext(superJSON, fileContext);
+
+    type = new Type(name, superType);
   }
 
-  return superType;
+  return type;
 }

package/src/utilities/node.js

@@ -4,19 +4,14 @@ import { parsersUtilities } from "occam-custom-grammars";
 
 import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { TYPE_RULE_NAME,
-         LABEL_RULE_NAME,
-         VARIABLE_RULE_NAME,
-         META_TYPE_RULE_NAME,
-         METAVARIABLE_RULE_NAME,
+import { LABEL_RULE_NAME,
+         VARIABLE_DECLARATION_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME,
          UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
 import { labelTokensFromLabelString,
-         constructorDeclarationTokensFromTermString,
          variableDeclarationTokensFromVariableString,
          unqualifiedStatementTokensFromStatementString,
-         metavariableDeclarationTokensFromMetavariableString,
          unqualifiedMetastatementTokensFromMetastatementString } from "../utilities/tokens";
 
 const { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
@@ -25,20 +20,10 @@ const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
-      typeNodeQuery = nodeQuery("/variableDeclaration/type!"),
       variableNodeQuery = nodeQuery("/variableDeclaration/variable!"),
-      metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType!"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable!"),
       metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export function termNodeFromTermString(termString, lexer, parser) {
-  const constructorDeclarationTokens = constructorDeclarationTokensFromTermString(termString, parser),
-        termNode = termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser);
-
-  return termNode;
-}
-
 export function labelNodeFromLabelString(labelString, lexer, parser) {
   const labelTokens = labelTokensFromLabelString(labelString, lexer),
         labelNode = labelNodeFromLabelTokens(labelTokens, parser);
@@ -46,13 +31,6 @@ export function labelNodeFromLabelString(labelString, lexer, parser) {
   return labelNode;
 }
 
-export function typeNodeFromVariableString(variableString, lexer, parser) {
-  const variableDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
-        typeNode = typeNodeFromVariableVariableDeclarationTokens(variableDeclarationTokens, parser);
-
-  return typeNode;
-}
-
 export function variableNodeFromVariableString(variableString, lexer, parser) {
   const variableTDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
         variableNode = variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser);
@@ -67,20 +45,6 @@ export function statementNodeFromStatementString(statementString, lexer, parser)
   return statementNode;
 }
 
-export function metaTypeNodeFromMetavariableString(metavariableString, lexer, parser) {
-  const metavariableDeclarationTokens = metavariableDeclarationTokensFromMetavariableString(metavariableString, lexer),
-        metaTypeNode = metaTypeNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser);
-
-  return metaTypeNode;
-}
-
-export function metavariableNodeFromMetavariableString(metavariableString, lexer, parser) {
-  const metavariableDeclarationTokens = metavariableDeclarationTokensFromMetavariableString(metavariableString, lexer),
-        metavariableNode = metavariableNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser);
-
-  return metavariableNode;
-}
-
 export function metastatementNodeFromMetastatementString(metastatementString, lexer, parser) {
   const unqualifiedMetastatementTokens = unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer),
         metastatementNode = metastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser);
@@ -102,27 +66,6 @@ export function statementNodeFromUnqualifiedStatementTokens(unqualifiedStatement
   return statementNode;
 }
 
-export function typeNodeFromVariableVariableDeclarationTokens(variableDeclarationTokens, parser) {
-  const typeDeclarationNode = typeDeclarationNodeFromVariableDeclarationTokens(variableDeclarationTokens, parser),
-        typeNode = typeNodeQuery(typeDeclarationNode);
-
-  return typeNode;
-}
-
-export function metaTypeNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
-  const metaTypeDeclarationNode = metaTypeDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser),
-        metaTypeNode = metaTypeNodeQuery(metaTypeDeclarationNode);
-
-  return metaTypeNode;
-}
-
-export function metavariableNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
-  const metavariableDeclarationNode = metavariableDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser),
-        metavariableNode = metavariableNodeQuery(metavariableDeclarationNode);
-
-  return metavariableNode;
-}
-
 export function variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser) {
   const variableDeclarationNode = variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser),
         variableNode = variableNodeQuery(variableDeclarationNode);
@@ -144,15 +87,8 @@ export function labelNodeFromLabelTokens(labelTokens, parser) {
   return labelNode;
 }
 
-export function typeDeclarationNodeFromVariableDeclarationTokens(variableDeclarationTokens, parser) {
-  const ruleName = TYPE_RULE_NAME,
-        typeDeclarationNode = nodeFromTokensRuleNameAndParser(variableDeclarationTokens, ruleName, parser);
-
-  return typeDeclarationNode;
-}
-
 export function variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser) {
-  const ruleName = VARIABLE_RULE_NAME,
+  const ruleName = VARIABLE_DECLARATION_RULE_NAME,
         variableDeclarationNode = nodeFromTokensRuleNameAndParser(variableTDeclarationTokens, ruleName, parser);
 
   return variableDeclarationNode;
@@ -165,13 +101,6 @@ export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifi
   return unqualifiedStatementNode;
 }
 
-export function metaTypeDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
-  const ruleName = META_TYPE_RULE_NAME,
-        metaTypeDeclarationNode = nodeFromTokensRuleNameAndParser(metavariableDeclarationTokens, ruleName, parser);
-
-  return metaTypeDeclarationNode;
-}
-
 export function constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
   const ruleName = CONSTRUCTOR_DECLARATION_RULE_NAME,
         constructorDeclarationNode = nodeFromTokensRuleNameAndParser(constructorDeclarationTokens, ruleName, parser);
@@ -179,13 +108,6 @@ export function constructorDeclarationNodeFromConstructorDeclarationTokens(const
   return constructorDeclarationNode;
 }
 
-export function metavariableDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
-  const ruleName = METAVARIABLE_RULE_NAME,
-        metavariableDeclarationNode = nodeFromTokensRuleNameAndParser(metavariableDeclarationTokens, ruleName, parser);
-
-  return metavariableDeclarationNode;
-}
-
 export function unqualifiedMetastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser) {
   const ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
         unqualifiedMetastatementNode = nodeFromTokensRuleNameAndParser(unqualifiedMetastatementTokens, ruleName, parser);

package/src/utilities/tokens.js

@@ -40,14 +40,6 @@ export function unqualifiedStatementTokensFromStatementString(statementString, l
   return unqualifiedStatementTokens;
 }
 
-export function metavariableDeclarationTokensFromMetavariableString(metavariableString, lexer) {
-  const metavariableDeclarationContent = `Metavariable ${metavariableString}
-`,
-        metavariableDeclarationTokens = tokensFromContentAndLexer(metavariableDeclarationContent, lexer);
-
-  return metavariableDeclarationTokens;
-}
-
 export function unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer) {
   const unqualifiedMetastatementContent = `${metastatementString}
 `,

package/src/variable.js

@@ -1,8 +1,7 @@
 "use strict";
 
-import Type from "./type";
-
 import { nodeAsString } from "./utilities/string";
+import { typeFromJSONAndFileContext } from "./type";
 import { variableNodeFromVariableString } from "./utilities/node";
 
 export default class Variable {
@@ -86,13 +85,17 @@ export default class Variable {
 
     json = type;  ///
 
-    type = Type.fromJSONAndFileContext(json, fileContext);
+    type = typeFromJSONAndFileContext(json, fileContext);
+
+    const variable = new Variable(node, type);
 
-    const typeName = type.getName();
+    return variable;
+  }
 
-    type = fileContext.findTypeByTypeName(typeName); ///
+  static fromVariableAndType(variable, type) {
+    const node = variable.getNode();
 
-    const variable = new Variable(node, type);
+    variable = new Variable(node, type);  ///
 
     return variable;
   }

package/src/verifier/node/statementAsCombinator.js

@@ -3,7 +3,7 @@
 import NodeVerifier from "../../verifier/node";
 import verifyStatement from "../../verify/statement";
 
-import { verifyStandaloneTerm, verifyType } from "./../../verifier/node/termAsConstructor";
+import { verifyType, verifyStandaloneTerm } from "./../../verifier/node/termAsConstructor";
 import { TYPE_RULE_NAME, TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../../ruleNames";
 
 class StatementAsCombinatorNodeVerifier extends NodeVerifier {

package/src/verify/axiom.js

@@ -4,7 +4,7 @@ import Axiom from "../axiom";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
 import verifyConsequent from "../verify/consequent";
-import verifySupposition from "../verify/supposition";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -28,13 +28,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
   if (labelsVerified) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(axiomNode),
-          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-            if (suppositionVerified) {
-              return true;
-            }
-          });
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],

package/src/verify/conclusion.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Conclusion from "../conclusion";
-import verifyUnqualifiedMetastatement from "./metastatement/unqualified";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 

package/src/verify/conjecture.js

@@ -4,8 +4,8 @@ import Conjecture from "../conjecture";
 import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
-import verifyConsequent from "./consequent";
-import verifySupposition from "./supposition";
+import verifyConsequent from "../verify/consequent";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -30,13 +30,7 @@ export default function verifyConjecture(conjectureNode, fileContext) {
   if (labelsVerified) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(conjectureNode),
-          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-            if (suppositionVerified) {
-              return true;
-            }
-          });
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],

package/src/verify/derivation.js

@@ -2,7 +2,7 @@
 
 import ProofStep from "../step/proof";
 import LocalContext from "../context/local";
-import verifySupposition from "../verify/supposition";
+import verifySuppositions from "../verify/suppositions";
 import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
@@ -53,13 +53,7 @@ function verifySubproof(subproofNode, localContext) {
 
   const suppositions = [],
         suppositionNodes = suppositionNodesQuery(subproofNode),
-        suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-          const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-          if (suppositionVerified) {
-            return true;
-          }
-        });
+        suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
   if (suppositionsVerified) {
     const subDerivationNode = subDerivationNodeQuery(subproofNode),

package/src/verify/equality.js

@@ -19,7 +19,7 @@ export default function verifyEquality(equalityNode, assignments, derived, conte
 
   const verifyEqualityFunctions = [
     verifyDerivedEquality,
-    verifyStandaloneEquality
+    verifyGivenEquality
   ];
 
   equalityVerified = verifyEqualityFunctions.some((verifyEqualityFunction) => {
@@ -82,13 +82,13 @@ function verifyDerivedEquality(equalityNode, assignments, derived, context, veri
   return derivedEqualityVerified;
 }
 
-function verifyStandaloneEquality(equalityNode, assignments, derived, context, verifyAhead) {
-  let standaloneEqualityVerified = false;
+function verifyGivenEquality(equalityNode, assignments, derived, context, verifyAhead) {
+  let givenEqualityVerified = false;
 
   if (!derived) {
     const equalityString = context.nodeAsString(equalityNode);
 
-    context.trace(`Verifying the '${equalityString}' standalone equality...`, equalityNode);
+    context.trace(`Verifying the '${equalityString}' given equality...`, equalityNode);
 
     const terms = [],
           leftTermNode = leftTermNodeQuery(equalityNode),
@@ -122,12 +122,12 @@ function verifyStandaloneEquality(equalityNode, assignments, derived, context, v
             return verifiedAhead;
           });
 
-    standaloneEqualityVerified = termsVerified; ///
+    givenEqualityVerified = termsVerified; ///
 
-    if (standaloneEqualityVerified) {
-      context.trace(`...verified the '${equalityString}' standalone equality.`, equalityNode);
+    if (givenEqualityVerified) {
+      context.trace(`...verified the '${equalityString}' given equality.`, equalityNode);
     }
   }
 
-  return standaloneEqualityVerified;
+  return givenEqualityVerified;
 }

package/src/verify/lemma.js

@@ -4,8 +4,8 @@ import Lemma from "../lemma";
 import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
-import verifyConsequent from "./consequent";
-import verifySupposition from "./supposition";
+import verifyConsequent from "../verify/consequent";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { EMPTY_STRING } from "../constants";
@@ -33,13 +33,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
   if (labelsVerified) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(lemmaNode),
-          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-            if (suppositionVerified) {
-              return true;
-            }
-          });
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],

package/src/verify/premises.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import verifyPremise from "../verify/premise";
+
+export default function verifyPremises(premiseNodes, premises, localMetaContext) {
+  let premisesVerified;
+
+  premisesVerified = premiseNodes.every((premiseNode) => {
+    const premiseVerified = verifyPremise(premiseNode, premises, localMetaContext);
+
+    if (premiseVerified) {
+      return true;
+    }
+  });
+
+  return premisesVerified;
+}

package/src/verify/rule.js

@@ -2,7 +2,7 @@
 
 import Rule from "../rule";
 import verifyLabels from "../verify/labels";
-import verifyPremise from "../verify/premise";
+import verifyPremises from "../verify/premises";
 import verifyRuleProof from "../verify/ruleProof";
 import LocalMetaContext from "../context/localMeta";
 import verifyConclusion from "../verify/conclusion";
@@ -30,13 +30,7 @@ export default function verifyRule(ruleNode, fileContext) {
   if (labelsVerified) {
     const premises = [],
           premiseNodes = premisesNodeQuery(ruleNode),
-          premisesVerified = premiseNodes.every((premiseNode) => {
-            const premiseVerified = verifyPremise(premiseNode, premises, localMetaContext);
-
-            if (premiseVerified) {
-              return true;
-            }
-          });
+          premisesVerified = verifyPremises(premiseNodes, premises, localMetaContext);
 
     if (premisesVerified) {
       const conclusions = [],

package/src/verify/ruleDerivation.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import MetaproofStep from "../step/metaproof";
-import verifyPremise from "../verify/premise";
+import verifyPremises from "../verify/premises";
 import LocalMetaContext from "../context/localMeta";
 import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
@@ -53,13 +53,11 @@ function verifyRuleSubproof(ruleSubproofNode, localMetaContext) {
 
   const premises = [],
         premiseNodes = premiseNodesQuery(ruleSubproofNode),
-        premisesVerified = premiseNodes.every((premiseNode) => {
-          const premiseVerified = verifyPremise(premiseNode, premises, localMetaContext);
+        premisesVerified = verifyPremises(premiseNodes, premises, localMetaContext);
 
-          if (premiseVerified) {
-            return true;
-          }
-        });
+        if (premiseVerified) {
+          return true;
+        }
 
   if (premisesVerified) {
     const ruleSubDerivationNode = ruleSubDerivationNodeQuery(ruleSubproofNode),

package/src/verify/supposition.js

@@ -9,7 +9,7 @@ import { nodeQuery } from "../utilities/query";
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement!");
 
-export default function verifySupposition(suppositionNode, suppositions, localContext) {
+export default function verifySupposition(suppositionNode, suppositions, assignments, localContext) {
   let suppositionVerified;
 
   const suppositionString = localContext.nodeAsString(suppositionNode);
@@ -17,7 +17,6 @@ export default function verifySupposition(suppositionNode, suppositions, localCo
   localContext.trace(`Verifying the '${suppositionString}' supposition...`, suppositionNode);
 
   const derived = false,
-        assignments = [],
         unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
         unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
@@ -30,14 +29,6 @@ export default function verifySupposition(suppositionNode, suppositions, localCo
 
     localContext.addProofStep(proofStep);
 
-    assignments.every((assignment) => {
-      const assigned = assignment.assign(localContext);
-
-      if (assigned) {
-        return true;
-      }
-    });
-
     suppositionVerified = true;
   }
 

package/src/verify/suppositions.js

@@ -0,0 +1,29 @@
+"use strict";
+
+import verifySupposition from "../verify/supposition";
+
+export default function verifySuppositions(suppositionNodes, suppositions, localContext) {
+  let suppositionsVerified;
+
+  const assignments = [];
+
+  suppositionsVerified = suppositionNodes.every((suppositionNode) => {
+    const suppositionVerified = verifySupposition(suppositionNode, suppositions, assignments, localContext);
+
+    if (suppositionVerified) {
+      return true;
+    }
+  });
+
+  if (suppositionsVerified) {
+    suppositionsVerified = assignments.every((assignment) => {  ///
+      const assigned = assignment.assign(localContext);
+
+      if (assigned) {
+        return true;
+      }
+    });
+  }
+
+  return suppositionsVerified;
+}

package/src/verify/term.js

@@ -67,13 +67,11 @@ export function verifyTermAsVariable(termNode, variables, context, verifyAhead)
 
     context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
 
-    const variablePresent = context.isVariablePresentByVariableNode(variableNode);
+    const variable = context.findVariableByVariableNode(variableNode);
 
-    if (variablePresent) {
+    if (variable !== null) {
       let verifiedAhead;
 
-      const variable = context.findVariableByVariableNode(variableNode);
-
       variables.push(variable);
 
       verifiedAhead = verifyAhead();

package/src/verify/theorem.js

@@ -5,7 +5,7 @@ import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
 import verifyConsequent from "../verify/consequent";
-import verifySupposition from "../verify/supposition";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -30,13 +30,7 @@ export default function verifyTheorem(theoremNode, fileContext) {
   if (labelsVerified) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(theoremNode),
-          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-            if (suppositionVerified) {
-              return true;
-            }
-          });
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],