occam-verify-cli 1.0.396 → 1.0.404

package/src/ontology/term.js

@@ -35,37 +35,10 @@ export default define(class Term {
     this.type = type;
   }
 
-  getVariable(context) {
-    const { Variable } = ontology,
-          termNode = this.node, ///
-          variable = Variable.fromTermNode(termNode, context);
-
-    return variable;
-  }
-
-  getVariables(context) {
-    const termNode = this.node,
-          variableNodes = termNode.getVariableNodes(),
-          variables = variableNodes.map((variableNode) => {
-            const { Variable } = ontology,
-                  variable = Variable.fromVariableNode(variableNode, context);
-
-            return variable;
-          });
-
-    compress(variables, (variableA, variableB) => {
-      const variableAEqualToVariableB = variableA.isEqualTo(variableB);
-
-      if (variableAEqualToVariableB) {
-        return true;
-      }
-    });
-
-    return variables;
-  }
-
   matchTermNode(termNode) { return this.node.match(termNode); }
 
+  isSimple() { return this.node.isSimple();}
+
   isProvisional() { return this.type.isProvisional(); }
 
   isEqualTo(term) {
@@ -75,16 +48,9 @@ export default define(class Term {
     return equalTo;
   }
 
-  isSimple() {
-    const termNode = this.node,
-          singularVariableNode = termNode.getSingularVariableNode(),
-          simple = (singularVariableNode !== null);
-
-    return simple;
-  }
-
   isGrounded(definedVariables, context) {
-    const variables = this.getVariables(context);
+    const term  = this, ///
+          variables = variablesFromTerm(term, context);
 
     filter(variables, (variable) => {
       const definedVariablesIncludesVariable = definedVariables.includes(variable);
@@ -102,7 +68,8 @@ export default define(class Term {
   }
 
   isInitiallyGrounded(context) {
-    const variables = this.getVariables(context),
+    const term  = this, ///
+          variables = variablesFromTerm(term, context),
           variablesLength = variables.length,
           initiallyGrounded = (variablesLength === 0);
 
@@ -274,3 +241,24 @@ export default define(class Term {
   }
 });
 
+export function variablesFromTerm(term, context) {
+  const termNode = term.getNode(),
+        variableNodes = termNode.getVariableNodes(),
+        variables = variableNodes.map((variableNode) => {
+          const variableIdentifier = variableNode.getVariableIdentifier(),
+                variable = context.findVariableByVariableIdentifier(variableIdentifier);
+
+          return variable;
+        });
+
+  compress(variables, (variableA, variableB) => {
+    const variableAEqualToVariableB = variableA.isEqualTo(variableB);
+
+    if (variableAEqualToVariableB) {
+      return true;
+    }
+  });
+
+  return variables;
+}
+

package/src/ontology/topLevelAssertion.js

@@ -4,7 +4,6 @@ import { arrayUtilities } from "necessary";
 
 import ontology from "../ontology";
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
 
 import { labelsFromJSON,
          deductionFromJSON,
@@ -175,7 +174,8 @@ export default class TopLevelAssertion {
     if (this.proof === null) {
       proofVerifies = true;
     } else {
-      const substitutions = Substitutions.fromNothing();
+      const { Substitutions } = ontology,
+            substitutions = Substitutions.fromNothing();
 
       proofVerifies = this.proof.verify(substitutions, this.deduction, context);
     }

package/src/ontology/topLevelMetaAssertion.js

@@ -2,7 +2,6 @@
 
 import ontology from "../ontology";
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
 
 import { proofFromProofNode, deductionFromDeductionNode, suppositionsFromSuppositionNodes } from "./topLevelAssertion";
 import { labelFromJSON,
@@ -169,7 +168,8 @@ export default class TopLevelMetaAssertion {
   }
 
   static fromNode(Class, node, context) {
-    const topLevelAssertionNode = node, ///
+    const { Substitutions } = ontology,
+          topLevelAssertionNode = node, ///
           proofNode = topLevelAssertionNode.getProofNode(),
           labelNode = topLevelAssertionNode.getLabelNode(),
           deductionNode = topLevelAssertionNode.getDeductionNode(),

package/src/ontology/variable.js

@@ -172,60 +172,6 @@ export default define(class Variable {
     return termUnifies;
   }
 
-  unifyTermVariable(termVariable, substitutions, generalContext, specificContext) {
-    let termVariableUnifies = false;
-
-    const variableString = this.string, ///
-          termVariableString = termVariable.getString();
-
-    specificContext.trace(`Unifying the '${termVariableString}' term variable with the '${variableString}' variable...`);
-
-    let context,
-        variable;
-
-    variable = this; ///
-
-    const substitution = substitutions.findSubstitutionByVariable(variable);
-
-    if (substitution !== null) {
-      context = specificContext;  ///
-
-      const substitutionTermVariableEqualToTerm = substitution.isTermVariableEqualToTerm(termVariable, context);
-
-      if (substitutionTermVariableEqualToTerm) {
-        termVariableUnifies = true;
-      }
-    } else {
-      context = generalContext;  ///
-
-      const variableIdentifier = variable.getIdentifier();
-
-      variable = context.findVariableByVariableIdentifier(variableIdentifier);
-
-      context = specificContext;  ///
-
-      const variableType = variable.getType(),
-            termVariableType = termVariable.getType(),
-            termVariableTypeEqualToOrSubTypeOfVariableType = termVariableType.isEqualToOrSubTypeOf(variableType);
-
-      if (termVariableTypeEqualToOrSubTypeOfVariableType) {
-        const { TermSubstitution } = ontology,
-              termSubstitution = TermSubstitution.fromTernVariableAndVariable(termVariable, variable, context),
-              substitution = termSubstitution;  ///
-
-        substitutions.addSubstitution(substitution, context);
-
-        termVariableUnifies = true;
-      }
-    }
-
-    if (termVariableUnifies) {
-      specificContext.debug(`...unified the '${termVariableString}' term variable with the '${variableString}' variable.`);
-    }
-
-    return termVariableUnifies;
-  }
-
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
           string = this.string, ///

package/src/preamble.js

@@ -31,23 +31,26 @@ 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 Declaration from "./ontology/declaration";
 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 DefinedAssertion from "./ontology/assertion/defined";
 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 ProcedureReference from "./ontology/procedureReference";
 import VariableDeclaration from "./ontology/declaration/variable";
 import BracketedCombinator from "./ontology/combinator/bracketed";
 import BracketedConstructor from "./ontology/constructor/bracketed";

package/src/ruleNames.js

@@ -21,28 +21,30 @@ export const EQUALITY_RULE_NAME = "equality";
 export const VARIABLE_RULE_NAME = "variable";
 export const SUBPROOF_RULE_NAME = "subproof";
 export const NONSENSE_RULE_NAME = "nonsense";
-export const SIGNATURE_RULE_NAME = "signature";
+export const DOCUMENT_RULE_NAME = "document";
+export const RULE_BODY_RULE_NAME = "ruleBody";
 export const META_TYPE_RULE_NAME = "metaType";
+export const SIGNATURE_RULE_NAME = "signature";
 export const PARAMETER_RULE_NAME = "parameter";
 export const DEDUCTION_RULE_NAME = "deduction";
 export const JUDGEMENT_RULE_NAME = "judgement";
 export const REFERENCE_RULE_NAME = "reference";
 export const STATEMENT_RULE_NAME = "statement";
-export const RULE_BODY_RULE_NAME = "ruleBody";
 export const META_LEMMA_RULE_NAME = "metaLemma";
+export const AXIOM_BODY_RULE_NAME = "axiomBody";
+export const LEMMA_BODY_RULE_NAME = "lemmaBody";
 export const COMBINATOR_RULE_NAME = "combinator";
 export const CONCLUSION_RULE_NAME = "conclusion";
 export const CONJECTURE_RULE_NAME = "conjecture";
 export const DERIVATION_RULE_NAME = "derivation";
 export const HYPOTHESIS_RULE_NAME = "hypothesis";
-export const AXIOM_BODY_RULE_NAME = "axiomBody";
-export const LEMMA_BODY_RULE_NAME = "lemmaBody";
+export const ASSUMPTION_RULE_NAME = "assumption";
+export const PLACEHOLDER_RULE_NAME = "_"; ///
+export const RULE_HEADER_RULE_NAME = "ruleHeader";
 export const TYPE_PREFIX_RULE_NAME = "typePrefix";
 export const SUPPOSITION_RULE_NAME = "supposition";
 export const CONSTRUCTOR_RULE_NAME = "constructor";
-export const DECLARATION_RULE_NAME = "declaration";
 export const METATHEOREM_RULE_NAME = "metatheorem";
-export const RULE_HEADER_RULE_NAME = "ruleHeader";
 export const AXIOM_HEADER_RULE_NAME = "axiomHeader";
 export const LEMMA_HEADER_RULE_NAME = "lemmaHeader";
 export const THEOREM_BODY_RULE_NAME = "theoremBody";
@@ -57,18 +59,18 @@ export const META_LEMMA_BODY_RULE_NAME = "metaLemmaBody";
 export const CONJECTURE_BODY_RULE_NAME = "conjectureBody";
 export const METATHEOREM_BODY_RULE_NAME = "metatheoremBody";
 export const META_LEMMA_HEADER_RULE_NAME = "metaLemmaHeader";
+export const CONJECTURE_HEADER_RULE_NAME = "conjectureHeader";
 export const PROPERTY_RELATION_RULE_NAME = "propertyRelation";
 export const DEFINED_ASSERTION_RULE_NAME = "definedAssertion";
 export const TERM_SUBSTITUTION_RULE_NAME = "termSubstitution";
-export const CONJECTURE_HEADER_RULE_NAME = "conjectureHeader";
 export const METATHEOREM_HEADER_RULE_NAME = "metatheoremHeader";
 export const PROPERTY_ASSERTION_RULE_NAME = "propertyAssertion";
 export const SUBPROOF_ASSERTION_RULE_NAME = "subproofAssertion";
 export const FRAME_SUBSTITUTION_RULE_NAME = "frameSubstitution";
+export const PARENTHESISED_LABEL_RULE_NAME = "parenthesisedLabel";
 export const PROCEDURE_REFERENCE_RULE_NAME = "procedureReference";
 export const CONTAINED_ASSERTION_RULE_NAME = "containedAssertion";
 export const SATISFIES_ASSERTION_RULE_NAME = "satisfiesAssertion";
-export const PARENTHESISED_LABEL_RULE_NAME = "parenthesisedLabel";
 export const PARENTHESISED_LABELS_RULE_NAME = "parenthesisedLabels";
 export const PROPERTY_DECLARATION_RULE_NAME = "propertyDeclaration";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";

package/src/unifier/intrinsicLevel.js

@@ -3,7 +3,6 @@
 import Unifier from "../unifier";
 
 import { nodeQuery } from "../utilities/query";
-import { variableIdentifierFromVariableNode, termVariableIdentifierFromTermNode } from "../utilities/variable";
 
 const termNodeQuery = nodeQuery("/term"),
       termVariableNodeQuery = nodeQuery("/term/variable!");
@@ -24,11 +23,11 @@ class IntrinsicLevelUnifier extends Unifier {
       generalNodeQuery: termVariableNodeQuery,
       specificNodeQuery: termNodeQuery,
       unify: (generalTermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
-        let termUnifies = false;
+        let termUnifies;
 
         const termNode = specificTermNode, ///
               variableNode = generalTermVariableNode, ///
-              variableIdentifier = variableIdentifierFromVariableNode(variableNode);
+              variableIdentifier = variableNode.getVariableIdentifier();
 
         let context;
 
@@ -40,17 +39,7 @@ class IntrinsicLevelUnifier extends Unifier {
 
         const term = context.findTermByTermNode(termNode);
 
-        if (term !== null) {
-          termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
-        } else {
-          const termVariaibleIdentifer = termVariableIdentifierFromTermNode(termNode),
-                termVariable = context.findVariableByVariableIdentifier(termVariaibleIdentifer),
-                termVariableUnifies = variable.unifyTermVariable(termVariable, substitutions, generalContext, specificContext);
-
-          if (termVariableUnifies) {
-            termUnifies = true;
-          }
-        }
+        termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
 
         return termUnifies;
       }

package/src/unifier/metaLevel.js

@@ -1,19 +1,18 @@
 "use strict";
 
-import ontology from "../ontology";
 import Unifier from "../unifier";
+import ontology from "../ontology";
 
 import { nodeQuery } from "../utilities/query";
 import { metavariableNameFromMetavariableNode } from "../utilities/metavariable";
-import { variableIdentifierFromVariableNode, termVariableIdentifierFromTermNode } from "../utilities/variable";
 
 const termNodeQuery = nodeQuery("/term"),
       frameNodeQuery = nodeQuery("/frame"),
       statementNodeQuery = nodeQuery("/statement"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
-      declarationMetavariableNodeQuery = nodeQuery("/declaration/metavariable!"),
-      frameDeclarationMetavariableNodeQuery = nodeQuery("/frame/declaration!/metavariable!");
+      assumptionMetavariableNodeQuery = nodeQuery("/assumption/metavariable!"),
+      frameAssumptionMetavariableNodeQuery = nodeQuery("/frame/assumption!/metavariable!");
 
 class MetaLevelUnifier extends Unifier {
   unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext) {
@@ -66,13 +65,13 @@ class MetaLevelUnifier extends Unifier {
       }
     },
     {
-      generalNodeQuery: frameDeclarationMetavariableNodeQuery,
+      generalNodeQuery: frameAssumptionMetavariableNodeQuery,
       specificNodeQuery: frameNodeQuery,
-      unify: (generalFrameDeclarationMetavariableNode, specificFrameNode, substitutions, generalContext, specificContext) => {
+      unify: (generalFrameAssumptionMetavariableNode, specificFrameNode, substitutions, generalContext, specificContext) => {
         let frameUnifies;
 
         const frameNode = specificFrameNode, ///
-              metavariableNode = generalFrameDeclarationMetavariableNode,  ///
+              metavariableNode = generalFrameAssumptionMetavariableNode,  ///
               metavariableName = metavariableNameFromMetavariableNode(metavariableNode);
 
         let context;
@@ -94,11 +93,11 @@ class MetaLevelUnifier extends Unifier {
       generalNodeQuery: termVariableNodeQuery,
       specificNodeQuery: termNodeQuery,
       unify: (generalTermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
-        let termUnifies = false;
+        let termUnifies;
 
         const termNode = specificTermNode, ///
               variableNode = generalTermVariableNode, ///
-              variableIdentifier = variableIdentifierFromVariableNode(variableNode);
+              variableIdentifier = variableNode.getVariableIdentifier();
 
         let context;
 
@@ -110,25 +109,15 @@ class MetaLevelUnifier extends Unifier {
 
         const term = context.findTermByTermNode(termNode);
 
-        if (term !== null) {
-          termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
-        } else {
-          const termVariaibleIdentifer = termVariableIdentifierFromTermNode(termNode),
-                termVariable = context.findVariableByVariableIdentifier(termVariaibleIdentifer),
-                termVariableUnifies = variable.unifyTermVariable(termVariable, substitutions, generalContext, specificContext);
-
-          if (termVariableUnifies) {
-           termUnifies = true;
-          }
-        }
+        termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
 
         return termUnifies;
       }
     },
     {
-      generalNodeQuery: declarationMetavariableNodeQuery,
-      specificNodeQuery: declarationMetavariableNodeQuery,
-      unify: (generalDeclarationMetavariableNode, specificDeclarationMetavariableNode, substitutions, generalContext, specificContext) => {
+      generalNodeQuery: assumptionMetavariableNodeQuery,
+      specificNodeQuery: assumptionMetavariableNodeQuery,
+      unify: (generalAssumptionMetavariableNode, specificAssumptionMetavariableNode, substitutions, generalContext, specificContext) => {
         let referenceUnifies;
 
         const { Reference } = ontology;
@@ -138,14 +127,14 @@ class MetaLevelUnifier extends Unifier {
 
         context = generalContext; ///
 
-        metavariableNode = generalDeclarationMetavariableNode;  ///
+        metavariableNode = generalAssumptionMetavariableNode;  ///
 
         const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
               metavariable = context.findMetavariableByMetavariableName(metavariableName);
 
         context = specificContext;  ///
 
-        metavariableNode = specificDeclarationMetavariableNode; ///
+        metavariableNode = specificAssumptionMetavariableNode; ///
 
         const reference = Reference.fromMetavariableNode(metavariableNode, context);
 

package/src/utilities/frame.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+
+const frameMetavariableNameNodeQuery = nodeQuery("/frame/assumption!/metavariable!/@name!");
+
+export function frameMetavariableNameFromFrameNode(frmaeNode) {
+  const frameMetavariableNameTerminalNode = frameMetavariableNameNodeQuery(frmaeNode),
+        frameMetavariableNameTerminalNodeContent = frameMetavariableNameTerminalNode.getContent(),
+        frameMetavariableName = frameMetavariableNameTerminalNodeContent; ///
+
+  return frameMetavariableName;
+}

package/src/utilities/statement.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+
+const statementMetavariableNameNodeQuery = nodeQuery("/statement/metavariable!/@name!");
+
+export function statementMetavariableNameFromFrameNode(frmaeNode) {
+  const statementMetavariableNameTerminalNode = statementMetavariableNameNodeQuery(frmaeNode),
+        statementMetavariableNameTerminalNodeContent = statementMetavariableNameTerminalNode.getContent(),
+        statementMetavariableName = statementMetavariableNameTerminalNodeContent; ///
+
+  return statementMetavariableName;
+}

package/src/utilities/substitutions.js

@@ -1,20 +1,32 @@
 "use strict";
 
-import ontology from "../ontology";
+import { nodeQuery } from "../utilities/query";
+import { frameMetavariableNameFromFrameNode } from "../utilities/frame";
+import { termVariableIdentifierFromTermNode } from "../utilities/variable";
+import { statementMetavariableNameFromFrameNode } from "../utilities/statement";
 
-export function termFromTermAndSubstitutions(term, substitutions, context) {
+const substitutionNodeQuery = nodeQuery("/statement/termSubstitution|frameSubstitution!");
+
+export function termFromTermAndSubstitutions(term, substitutions, generalContext, specificContext) {
   if (term !== null) {
-    const { Variable } = ontology,
-          termNode = term.getNode(),
-          variable = Variable.fromTermNode(termNode, context);
+    const termNode = term.getNode(),
+          termSimple = term.isSimple();
 
     term = null;  ///
 
-    if (variable !== null) {
-      const substitution = substitutions.findSubstitutionByVariable(variable);
+    if (termSimple) {
+      const termVariableIdentifier = termVariableIdentifierFromTermNode(termNode),
+            variableIdentifier = termVariableIdentifier,  ///
+            variable = generalContext.findVariableByVariableIdentifier(variableIdentifier);
+
+      if (variable !== null) {
+        const substitution = substitutions.findSubstitutionByVariable(variable);
+
+        if (substitution !== null) {
+          const termSubstitution = substitution;  ///
 
-      if (substitution !== null) {
-        term = substitution.getTerm();
+          term = termSubstitution.getTerm();
+        }
       }
     }
   }
@@ -22,21 +34,28 @@ export function termFromTermAndSubstitutions(term, substitutions, context) {
   return term;
 }
 
-export function frameFromFrameAndSubstitutions(frame, substitutions, context) {
+export function frameFromFrameAndSubstitutions(frame, substitutions, generalContext, specificContext) {
   if (frame !== null) {
-    const { Metavariable } = ontology,
-          frameNode = frame.getNode(),
-          metavariable = Metavariable.fromFrameNode(frameNode, context);
+    const frameNode = frame.getNode(),
+          frameSimple = frame.isSimple();
 
-    frame = null; ///
+    frame = null;  ///
 
-    if (metavariable !== null) {
-      let substitution = null;
+    if (frameSimple) {
+      const frameMetavariableName = frameMetavariableNameFromFrameNode(frameNode),
+            metavariableName = frameMetavariableName, ///
+            metavariable = generalContext.findMetavariableByMetavariableName(metavariableName);
+
+      if (metavariable !== null) {
+        let substitution = null;
 
-      substitution = substitutions.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution);
+        substitution = substitutions.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution);
 
-      if (substitution !== null) {
-        frame = substitution.getFrame();
+        if (substitution !== null) {
+          const frameSubstitution = substitution; ///
+
+          frame = frameSubstitution.getFrame();
+        }
       }
     }
   }
@@ -44,25 +63,34 @@ export function frameFromFrameAndSubstitutions(frame, substitutions, context) {
   return frame;
 }
 
-export function statementFromStatementAndSubstitutions(statement, substitutions, context) {
+export function statementFromStatementAndSubstitutions(statement, substitutions, generalContext, specificContext) {
   if (statement !== null) {
-    const { Metavariable } = ontology,
-          statementNode = statement.getNode(),
-          metavariable = Metavariable.fromStatementNode(statementNode, context);
+    const statementNode = statement.getNode(),
+          statementSimple = statement.isSimple();
+
+    if (statementSimple) {
+      statement = null;
 
-    statement = null; ///
+      let substitution = null;
 
-    if (metavariable !== null) {
-      let substitution;
+      const substitutionNode = substitutionNodeQuery(statementNode);
+
+      if (substitutionNode !== null) {
+        substitution = generalContext.findSubstitutionBySubstitutionNode(substitutionNode);
+      }
 
-      const { TermSubstitution, FrameSubstitution } = ontology;
+      const statementMetavariableName = statementMetavariableNameFromFrameNode(statementNode),
+            metavariableName = statementMetavariableName, ///
+            metavariable = generalContext.findMetavariableByMetavariableName(metavariableName);
 
-      substitution = TermSubstitution.fromStatement(statement, context) || FrameSubstitution.fromStatement(statement, context);
+      if (metavariable !== null) {
+        substitution = substitutions.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution);
 
-      substitution = substitutions.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution); ///
+        if (substitution !== null) {
+          const statementSubstitution = substitution; ///
 
-      if (substitution !== null) {
-        statement = substitution.getStatement();
+          statement = statementSubstitution.getStatement();
+        }
       }
     }
   }

package/src/utilities/variable.js

@@ -2,8 +2,7 @@
 
 import { nodeQuery } from "../utilities/query";
 
-const variableIdentifierNodeQuery = nodeQuery("/variable/@identifier!"),
-      termVariableIdentifierNodeQuery = nodeQuery("/term/variable!/@identifier!");
+const termVariableIdentifierNodeQuery = nodeQuery("/term/variable!/@identifier!");
 
 export function termVariableIdentifierFromTermNode(TermNode) {
   const termVariableIdentifierTerminalNode = termVariableIdentifierNodeQuery(TermNode),
@@ -12,11 +11,3 @@ export function termVariableIdentifierFromTermNode(TermNode) {
 
   return termVariableIdentifier;
 }
-
-export function variableIdentifierFromVariableNode(variableNode) {
-  const variableIdentifierTerminalNode = variableIdentifierNodeQuery(variableNode),
-        variableIdentifierTerminalNodeContent = variableIdentifierTerminalNode.getContent(),
-        variableIdentifier = variableIdentifierTerminalNodeContent; ///
-
-  return variableIdentifier;
-}