occam-verify-cli 0.0.1063 → 0.0.1066

package/src/context/local.js

@@ -10,8 +10,9 @@ import { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariab
 const { last, reverse } = arrayUtilities;
 
 class LocalContext {
-  constructor(context, variables, proofSteps, judgements, equivalences, metavariables) {
+  constructor(context, tokens, variables, proofSteps, judgements, equivalences, metavariables) {
     this.context = context;
+    this.tokens = tokens;
     this.variables = variables;
     this.proofSteps = proofSteps;
     this.judgements = judgements;
@@ -23,6 +24,10 @@ class LocalContext {
     return this.context;
   }
 
+  getTokens() {
+    return this.tokens;
+  }
+
   getVariables() {
     let variables = this.context.getVariables();
 
@@ -394,9 +399,47 @@ class LocalContext {
 
   findMetatheoremByReference(reference) { return this.context.findMetatheoremByReference(reference); }
 
-  nodeAsString(node) { return this.context.nodeAsString(node); }
+  nodeAsString(node, tokens = null) {
+    if (tokens === null) {
+      tokens = this.tokens;
+    }
+
+    const string = this.context.nodeAsString(node, tokens);
+
+    return string;
+  }
+
+  nodesAsString(node, tokens = null) {
+    if (tokens === null) {
+      tokens = this.tokens;
+    }
+
+    const string = this.context.nodesAsString(node, tokens);
+
+    return string;
+  }
+
+  nodeAsTokens(node, tokens = null) {
+    if (tokens === null) {
+      tokens = this.tokens;
+    }
+
+    tokens = this.context.nodeAsTokens(node, tokens); ///
+
+    return tokens;
+  }
+
+  nodesAsTokens(node, tokens = null) {
+    if (tokens === null) {
+      tokens = this.tokens;
+    }
 
-  nodesAsString(node) { return this.context.nodesAsString(node); }
+    tokens = this.context.nodesAsTokens(node, tokens);  ///
+
+    return tokens;
+  }
+
+  tokensAsString(tokens) { return this.context.tokensAsString(tokens); }
 
   trace(message, node) { this.context.trace(message, node); }
 
@@ -410,25 +453,39 @@ class LocalContext {
 
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
+          tokens = null,
           variables = [],
           proofSteps = [],
-          equivalences = [],
           judgements = [],
+          equivalences = [],
           metavariables = [],
-          localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables);
+          localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences, metavariables);
 
     return localContext;
   }
 
   static fromLocalContext(localContext) {
     const context = localContext,  ///
+          tokens = null,
           variables = [],
           proofSteps = [],
-          equivalences = [],
           judgements = [],
+          equivalences = [],
           metavariables = [];
 
-    localContext = new LocalContext(context, variables, proofSteps, judgements, equivalences, metavariables);  ///
+    localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences, metavariables);  ///
+
+    return localContext;
+  }
+
+  static fromFileContextAndTokens(fileContext, tokens) {
+    const context = fileContext,  ///
+          variables = [],
+          proofSteps = [],
+          judgements = [],
+          equivalences = [],
+          metavariables = [],
+          localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences, metavariables);  ///
 
     return localContext;
   }

package/src/metavariable.js

@@ -13,7 +13,7 @@ import { metavariableNodeFromMetavariableString } from "./utilities/node";
 const argumentNodeQuery = nodeQuery("/metavariable/argument"),
       metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType"),
       metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
-      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable");
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 class Metavariable {
   constructor(fileContext, string, node, name, metaType) {
@@ -174,40 +174,38 @@ class Metavariable {
           substitutionString = substitution.getString(),
           metavariableString = this.string; ///
 
-    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable givne the '${substitutionString}' substitution...`);
-
-    // let metavariableUnifiedWithStatementGivenSubstitution = false;
-    //
-    // const metavariableNode = metavariable.getNode(),
-    //   substitutionNode = substitution.getNode(),
-    //   complexSubstitution = substitutions.findComplexSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
-    //
-    // if (complexSubstitution !== null) {
-    //   const statementNode = statement.getNode(),
-    //     statementNodeMatches = complexSubstitution.matchStatementNode(statementNode);
-    //
-    //   if (statementNodeMatches) {
-    //     metavariableUnifiedWithStatementGivenSubstitution = true;
-    //   }
-    // } else {
-    //   const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNode),
-    //     metavariableA = localContextA.findMetavariableByMetavariableName(metavariableNameA),
-    //     metavariableB = metavariableFromStatementNode(statement, localContextB);
-    //
-    //   if (metavariableA === metavariableB) {
-    //     metavariableUnifiedWithStatementGivenSubstitution = false;  ///
-    //   } else {
-    //     const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContextA, localContextB),
-    //       substitution = statementForMetavariableSubstitution;  ///
-    //
-    //     substitutions.addSubstitution(substitution, localContextA, localContextB);
-    //
-    //     metavariableUnifiedWithStatementGivenSubstitution = true;
-    //   }
-    // }
+    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}' metavariable given the '${substitutionString}' substitution...`);
+
+    const statementNode = statement.getNode(),
+          metavariableNode = this.node, ///
+          substitutionNode = substitution.getNode(),
+          complexSubstitution = substitutions.findComplexSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
+
+    if (complexSubstitution !== null) {
+      const statementNodeMatches = complexSubstitution.matchStatementNode(statementNode);
+
+      if (statementNodeMatches) {
+        statementUnifiedGivenSubstitution = true;
+      }
+    } else {
+      const metavariable = metavariableFromStatementNode(statementNode, localContext);
+
+      if (this === metavariable) {  ///
+        statementUnifiedGivenSubstitution = false;  ///
+      } else {
+        const metavariable = this,  ///
+              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
+
+        substitution = statementForMetavariableSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, localContext);
+
+        statementUnifiedGivenSubstitution = true;
+      }
+    }
 
     if (statementUnifiedGivenSubstitution) {
-      localContext.trace(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable givne the '${substitutionString}' substitution.`);
+      localContext.trace(`...unified the '${statementString}' statement with the '${metavariableString}' metavariable given the '${substitutionString}' substitution.`);
     }
 
     return statementUnifiedGivenSubstitution;
@@ -294,6 +292,21 @@ function metaTypeFromJSON(json, fileContext) {
   return metaType;
 }
 
+function metavariableFromStatementNode(statementNode, localContext) {
+  let metavariable = null;
+
+  const statementMetavariableNode = statementMetavariableNodeQuery(statementNode)
+
+  if (statementMetavariableNode !== null) {
+    const metavariableNode = statementMetavariableNode, ///
+          metavariableName = metavariableNameFromMetavariableNode(metavariableNode);
+
+    metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+  }
+
+  return metavariable;
+}
+
 function statementMetavariableFromStatementNode(statementNode, localContext) {
   let statementMetavariable = null;
 

package/src/mixins/statement/unify.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import BracketedCombinator from "../../ocmbinator/bracketed";
+import BracketedCombinator from "../../combinator/bracketed";
 import statementWithCombinatorUnifier from "../../unifier/statementWithCombinator";
 
 function unifyWithBracketedCombinator(statement, assignments, stated, localContext) {

package/src/mixins/statement/verify.js

@@ -6,7 +6,8 @@ import TypeAssertion from "../../assertion/type";
 import DefinedAssertion from "../../assertion/defined";
 import SubproofAssertion from "../../assertion/subproof";
 import ContainedAssertion from "../../assertion/contained";
-import StatementSubstitution from "../../substitution/statement";
+import TermForVariableSubstitution from "../../substitution/termForVariable";
+import FrameForMetavariableSubstitution from "../../substitution/frameForMetavariable";
 
 import verifyFrame from "../../verify/frame";
 import verifyJudgement from "../../verify/judgement";
@@ -41,12 +42,12 @@ function verifyAsMetavariable(statement, assignments, stated, localContext) {
     if (metavariableVerified) {
       let substitutionVerified = true;
 
-      const statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext);
+      const substitution = FrameForMetavariableSubstitution.fromStatementNode(statementNode, localContext) ||
+                             TermForVariableSubstitution.fromStatementNode(statementNode, localContext) ||
+                               null;
 
-      if (statementSubstitution !== null) {
-        const statementSubstitutionVerified = statementSubstitution.verify(assignments, stated, localContext);
-
-        substitutionVerified = statementSubstitutionVerified; ///
+      if (substitution !== null) {
+        substitutionVerified = substitution.verify(assignments, stated, localContext);
       }
 
       verifiedAsMetavariable = substitutionVerified; ///

package/src/premise.js

@@ -1,8 +1,6 @@
 "use strict";
 
 import shim from "./shim";
-import LocalContext from "./context/local";
-import metaLevelUnifier from "./unifier/metaLevel";
 import SubproofAssertion from "./assertion/subproof";
 import UnqualifiedStatement from "./statement/unqualified";
 
@@ -80,26 +78,15 @@ export default class Premise {
   unifyStatement(statement, substitutions, localContext) {
     let statementUnified;
 
-    const premise = this, ///
-          statementString = statement.getString(),
-          premiseStatement = premise.getStatement(),
-          premiseStatementString = premiseStatement.getString();
-
-    localContext.trace(`Unifying the '${statementString}' statement with the premise's '${premiseStatementString}' statement...`);
+    const statementString = statement.getString(),
+          premiseString = this.getString();
 
-    const statementNode = statement.getNode(),
-          premiseStatementNode = premiseStatement.getNode(),
-          nodeA = premiseStatementNode,  ///
-          nodeB = statementNode,  ///
-          fileContextA = this.fileContext,  ///
-          localContextA = LocalContext.fromFileContext(fileContextA),
-          localContextB = localContext, ///
-          unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+    localContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
 
-    statementUnified = unified; ///
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, this.fileContext, localContext);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the premise's '${premiseStatementString}' statement.`);
+      localContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
     }
 
     return statementUnified;

package/src/proofStep.js

@@ -71,7 +71,7 @@ class ProofStep {
 
       verified = qualifiedStatementVerified;  ///
     } else if (this.unqualifiedStatement !== null) {
-      const stated = true,
+      const stated = false,
             assignments = [],
             unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
 

package/src/ruleNames.js

@@ -2,6 +2,5 @@
 
 export const VARIABLE_RULE_NAME = "variable";
 export const METAVARIABLE_RULE_NAME = "metavariable";
-export const SUBSTITUTION_RULE_NAME = "substitution";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";

package/src/statement/unqualified.js

@@ -45,6 +45,23 @@ export default class UnqualifiedStatement {
     return verified;
   }
 
+  unifyStatement(statement, substitutions, fileContext, localContext) {
+    let statementUnified;
+
+    const statementString = statement.getString(),
+          unqualifiedStatementString = this.getString();  ///
+
+    localContext.trace(`Unifying the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement...`);
+
+    statementUnified = this.statement.unifyStatement(statement, substitutions, fileContext, localContext);
+
+    if (statementUnified) {
+      localContext.debug(`...unified the '${statementString}' statement with the '${unqualifiedStatementString}' unqualified statement.`);
+    }
+
+    return statementUnified;
+  }
+
   toJSON() {
     const statementJSON = this.statement.toJSON(),
           statement = statementJSON,  ///

package/src/statement.js

@@ -3,22 +3,26 @@
 import shim from "./shim";
 import unifyMixins from "./mixins/statement/unify";
 import verifyMixins from "./mixins/statement/verify";
-import StatementSubstitution from "./substitution/statement";
+import LocalContext from "./context/local";
+import metaLevelUnifier from "./unifier/metaLevel";
 import statementAsCombinatorVerifier from "./verifier/statementAsCombinator";
 
 import { nodeQuery, nodesQuery } from "./utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
-import { statementNodeFromStatementString } from "./utilities/node";
+import { statementTokensFromUnqualifiedStatementTokens, unqualifiedStatementTokensFromUnqualifiedStatementString } from "./utilities/tokens";
+import { statementNodeFromUnqualifiedStatementNode,
+         unqualifiedStatementStringFromStatementString,
+         unqualifiedStatementNodeFromUnqualifiedStatementTokens } from "./utilities/node";
 
 const statementNodeQuery = nodeQuery("/*//statement"),
       statementVariableNodesQuery = nodesQuery("/statement//variable"),
       statementMetavariableNodesQuery = nodesQuery("/statement//metavariable");
 
 class Statement {
-  constructor(string, node, substitution) {
+  constructor(string, node, tokens) {
     this.string = string;
     this.node = node;
-    this.substitution = substitution;
+    this.tokens = tokens;
   }
 
   getString() {
@@ -29,8 +33,8 @@ class Statement {
     return this.node;
   }
 
-  getSubstitution() {
-    return this.substitution;
+  getTokens() {
+    return this.tokens;
   }
 
   isEqualTo(statement) {
@@ -95,6 +99,32 @@ class Statement {
     return metavariableContained;
   }
 
+  unifyStatement(statement, substitutions, fileContext, localContext) {
+    let statementUnified;
+
+    const statementA = this,  ///
+          statementB = statement, ///
+          statementAString = statementA.getString(),
+          statementBString = statementB.getString();
+
+    localContext.trace(`Unifying the '${statementBString}' statement with the '${statementAString}' statement...`);
+
+    const statementANode = statementA.getNode(),
+          statementBNode = statementB.getNode(),
+          nodeA = statementANode, ///
+          nodeB = statementBNode, ///
+          fileContextA = fileContext, ///
+          localContextA = LocalContext.fromFileContextAndTokens(fileContextA, this.tokens),
+          localContextB = localContext, ///
+          unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+    statementUnified = unifiedAtMetaLevel; ///
+
+    localContext.debug(`...unified the '${statementBString}' statement with the '${statementAString}' statement.`);
+
+    return statementUnified;
+  }
+
   verify(assignments, stated, localContext) {
     let verified = false;
 
@@ -173,13 +203,8 @@ class Statement {
   }
 
   toJSON() {
-    const substitutionJSON = (this.substitution !== null) ?
-                                this.substitution.toJSON() :
-                                  null,
-          substitution = substitutionJSON,  ///
-          string = this.string, ///
+    const string = this.string, ///
           json = {
-            substitution,
             string
           };
 
@@ -191,18 +216,14 @@ class Statement {
           statementString = string, ///
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
-          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
-          node = statementNode;  ///
-
-    let { substitution } = json;
-
-    json = substitution;  ///
-
-    const statementSubstitution = StatementSubstitution.fromJSON(json, fileContext);
-
-    substitution = statementSubstitution; ///
-
-    const statement = new Statement(string, node, substitution);
+          unqualifiedStatementString = unqualifiedStatementStringFromStatementString(statementString),
+          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
+          statementTokens = statementTokensFromUnqualifiedStatementTokens(unqualifiedStatementTokens),
+          statementNode = statementNodeFromUnqualifiedStatementNode(unqualifiedStatementNode),
+          node = statementNode,  ///
+          tokens = statementTokens, ///
+          statement = new Statement(string, node, tokens);
 
     return statement;
   }
@@ -212,11 +233,10 @@ class Statement {
 
     if (statementNode !== null) {
       const node = statementNode, ///
-            string = localContext.nodeAsString(node),
-            statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext),
-            substitution = statementSubstitution; ///
+            tokens = localContext.nodeAsTokens(node),
+            string = localContext.tokensAsString(tokens);
 
-      statement = new Statement(string, node, substitution);
+      statement = new Statement(string, node, tokens);
     }
 
     return statement;
@@ -225,10 +245,9 @@ class Statement {
   static fromDefinedAssertionNode(definedAssertionNode, localContext) {
     const statementNode = statementNodeQuery(definedAssertionNode),
           node = statementNode, ///
-          string = localContext.nodeAsString(node),
-          statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext),
-          substitution = statementSubstitution, ///
-          statement = new Statement(string, node, substitution);
+          tokens = localContext.nodeAsTokens(node),
+          string = localContext.tokensAsString(tokens),
+          statement = new Statement(string, node, tokens);
 
     return statement;
   }
@@ -236,10 +255,9 @@ class Statement {
   static fromContainedAssertionNode(containedAssertionNode, localContext) {
     const statementNode = statementNodeQuery(containedAssertionNode),
           node = statementNode, ///
-          string = localContext.nodeAsString(node),
-          statementSubstitution = StatementSubstitution.fromStatementNode(statementNode, localContext),
-          substitution = statementSubstitution, ///
-          statement = new Statement(string, node, substitution);
+          tokens = localContext.nodeAsTokens(node),
+          string = localContext.tokensAsString(tokens),
+          statement = new Statement(string, node, tokens);
 
     return statement;
   }

package/src/substitution/frameForMetavariable.js

@@ -4,7 +4,8 @@ import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
 
-const substitutionFrameNodeQuery = nodeQuery("/substitution/frame!"),
+const substitutionNodeQuery = nodeQuery("/statement/substitution"),
+      substitutionFrameNodeQuery = nodeQuery("/substitution/frame!"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       substitutionMetavariableNodeQuery = nodeQuery("/substitution/metavariable!");
 
@@ -87,6 +88,30 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return frameForMetavariableSubstitution;
   }
 
+  static fromStatementNode(statementNode, localContext) {
+    let frameForMetavariableSubstitution = null;
+
+    const substitutionNode = substitutionNodeQuery(statementNode);
+
+    if (substitutionNode !== null) {
+      const substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
+
+      if (substitutionFrameNode !== null) {
+        const substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
+              metavariableNode = substitutionMetavariableNode,  ///
+              frameNode = substitutionFrameNode,  ///
+              localContextA = localContext, ///
+              localContextB = localContext, ///
+              string = stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB);
+
+        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode);
+      }
+
+    }
+
+    return frameForMetavariableSubstitution;
+  }
+
   static fromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB) {
     const string = stringFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB),
           frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode);

package/src/substitution/statementForMetavariable.js

@@ -81,7 +81,7 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     statement = Statement.fromStatementNode(statementNode, localContext); ///
 
     const metavariableNode = metavariable.getNode(),
-          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
+          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution);
 
     substitution = substitutionFromSubstitution(substitution, localContext);
 
@@ -91,53 +91,46 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 }
 
-function stringFromStatementAndMetavariable(statement, metavariable) {
-  const statementString = statement.getString(),
-        metavariableString = metavariable.getString(),
-        string = `[${statementString} for ${metavariableString}]`;
+function substitutionFromSubstitution(substitution, localContext) {
+  if (substitution === null) {
+    const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitution(substitution, localContext);
 
-  return string;
-}
+    if (termForVariableSubstitution !== null) {
+      substitution = termForVariableSubstitution; ///
+    }
+  }
 
+  if (substitution === null) {
+    const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitution(substitution, localContext);
 
-function substitutionFromSubstitution(substitution, localContextA, localContextB) {
-  // let substitution = null;
+    if (frameForMetavariableSubstitution !== null) {
+      substitution = frameForMetavariableSubstitution;  ///
+    }
+  }
 
-  debugger
+  return substitution;
+}
 
-  // if (substitution === null) {
-  //   const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitution(substitutionNode, localContextA, localContextB);
-  //
-  //   if (termForVariableSubstitution !== null) {
-  //     substitution = termForVariableSubstitution; ///
-  //   }
-  // }
-  //
-  // if (substitution === null) {
-  //   const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitution(substitutionNode, localContextA, localContextB);
-  //
-  //   if (frameForMetavariableSubstitution !== null) {
-  //     substitution = frameForMetavariableSubstitution;  ///
-  //   }
-  // }
+function stringFromStatementAndMetavariable(statement, metavariable) {
+  const statementString = statement.getString(),
+        metavariableString = metavariable.getString(),
+        string = `[${statementString} for ${metavariableString}]`;
 
-  return substitution;
+  return string;
 }
 
-function stringFromStatementMetavariableAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB) {
+function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution) {
   let string;
 
-  const statementNodeB = statementNode,  ///
-        statementStringB = localContextB.nodeAsString(statementNodeB),
-        metavariableNodeA = metavariableNode,  ///
-        metavariableStringA = localContextA.nodeAsString(metavariableNodeA);
+  const statementString = statement.getString(),
+        metavariableString = metavariable.getString();
 
   if (substitution === null) {
-    string = `[${statementStringB} for ${metavariableStringA}]`;
+    string = `[${statementString} for ${metavariableString}]`;
   } else {
-    const substitutionString = substitution.asString(localContextA, localContextA);
+    const substitutionString = substitution.getString();
 
-    string = `[${statementStringB} for ${metavariableStringA}${substitutionString}]`;
+    string = `[${statementString} for ${metavariableString}${substitutionString}]`;
   }
 
   return string;