occam-verify-cli 1.0.388 → 1.0.404

package/src/ontology/variable.js

@@ -127,13 +127,12 @@ export default define(class Variable {
 
     variable = this; ///
 
-    const substitutionPresent = substitutions.isSubstitutionPresentByVariable(variable);
+    const substitution = substitutions.findSubstitutionByVariable(variable);
 
-    if (substitutionPresent) {
+    if (substitution !== null) {
       context = specificContext;  ///
 
-      const substitution = substitutions.findSubstitutionByVariable(variable),
-            substitutionTermEqualToTerm = substitution.isTermEqualTo(term, context);
+      const substitutionTermEqualToTerm = substitution.isTermEqualToTerm(term, context);
 
       if (substitutionTermEqualToTerm) {
         termUnifies = true;
@@ -147,26 +146,20 @@ export default define(class Variable {
 
       context = specificContext;  ///
 
-      const termVerifies = term.verify(context, () => {
-        let verifiesAhead = false;
+      const termNode = term.getNode();
 
-        const termType = term.getType(),
-              variableType = variable.getType(),
-              termTypeEqualToOrSubTypeOfVariableType = termType.isEqualToOrSubTypeOf(variableType);
+      term = context.findTermByTermNode(termNode);
 
-        if (termTypeEqualToOrSubTypeOfVariableType) {
-          verifiesAhead = true;
-        }
+      const termType = term.getType(),
+            variableType = variable.getType(),
+            termTypeEqualToOrSubTypeOfVariableType = termType.isEqualToOrSubTypeOf(variableType);
 
-        return verifiesAhead;
-      });
-
-      if (termVerifies) {
+      if (termTypeEqualToOrSubTypeOfVariableType) {
         const { TermSubstitution } = ontology,
               termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context),
               substitution = termSubstitution;  ///
 
-        substitutions.addSubstitution(substitution, specificContext);
+        substitutions.addSubstitution(substitution, context);
 
         termUnifies = true;
       }

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

@@ -1,6 +1,5 @@
 "use strict";
 
-import ontology from "../ontology";
 import Unifier from "../unifier";
 
 import { nodeQuery } from "../utilities/query";
@@ -26,19 +25,19 @@ class IntrinsicLevelUnifier extends Unifier {
       unify: (generalTermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
         let termUnifies;
 
-        const { Term, Variable } = ontology,
-              termNode = specificTermNode, ///
-              variableNode = generalTermVariableNode; ///
+        const termNode = specificTermNode, ///
+              variableNode = generalTermVariableNode, ///
+              variableIdentifier = variableNode.getVariableIdentifier();
 
         let context;
 
         context = generalContext; ///
 
-        const variable = Variable.fromVariableNode(variableNode, context);
+        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
 
         context = specificContext;  ///
 
-        const term = Term.fromTermNode(termNode, context);
+        const term = context.findTermByTermNode(termNode);
 
         termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
 

package/src/unifier/metaLevel.js

@@ -1,18 +1,18 @@
 "use strict";
 
-import ontology from "../ontology";
 import Unifier from "../unifier";
+import ontology from "../ontology";
 
 import { nodeQuery } from "../utilities/query";
-import Metavariable from "./metavariable";
+import { metavariableNameFromMetavariableNode } from "../utilities/metavariable";
 
 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) {
@@ -32,30 +32,32 @@ class MetaLevelUnifier extends Unifier {
       unify: (generalStatementMetavariableNode, specificStatementNode, substitutions, generalContext, specificContext) => {
         let statementUnifies;
 
-        const { Metavariable, Statement } = ontology; ///
-
         let context,
+            statement,
             statementNode;
 
         context = generalContext; ///
 
         const metavariableNode = generalStatementMetavariableNode,  ///
-              metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
+              metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+              metavariable = context.findMetavariableByMetavariableName(metavariableName);
 
         const metavariableNodeParentNode = metavariableNode.getParentNode();
 
         statementNode = metavariableNodeParentNode; ///
 
+        statement = context.findStatementByStatementNode(statementNode);
+
         const { TermSubstitution, FrameSubstitution } = ontology,
-              frameSubstitution = FrameSubstitution.fromStatementNode(statementNode, context),
-              termSubstitution = TermSubstitution.fromStatementNode(statementNode, context),
+              frameSubstitution = FrameSubstitution.fromStatement(statement, context),
+              termSubstitution = TermSubstitution.fromStatement(statement, context),
               substitution = (frameSubstitution || termSubstitution);
 
         context = specificContext; ///
 
         statementNode = specificStatementNode;  ///
 
-        const statement = Statement.fromStatementNode(statementNode, context);
+        statement = context.findStatementByStatementNode(statementNode);
 
         statementUnifies = metavariable.unifyStatement(statement, substitution, substitutions, generalContext, specificContext);
 
@@ -63,24 +65,24 @@ 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 { Frame, Metavariable } = ontology,
-              frameNode = specificFrameNode, ///
-              metavariableNode = generalFrameDeclarationMetavariableNode;  ///
+        const frameNode = specificFrameNode, ///
+              metavariableNode = generalFrameAssumptionMetavariableNode,  ///
+              metavariableName = metavariableNameFromMetavariableNode(metavariableNode);
 
         let context;
 
         context = generalContext; ///
 
-        const metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
+        const metavariable = context.findMetavariableByMetavariableName(metavariableName);
 
         context = specificContext;  ///
 
-        const frame = Frame.fromFrameNode(frameNode, context);
+        const frame = context.findFrameByFrameNode(frameNode);
 
         frameUnifies = metavariable.unifyFrame(frame, substitutions, generalContext, specificContext);
 
@@ -93,19 +95,19 @@ class MetaLevelUnifier extends Unifier {
       unify: (generalTermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
         let termUnifies;
 
-        const { Term, Variable } = ontology,
-              termNode = specificTermNode, ///
-              variableNode = generalTermVariableNode; ///
+        const termNode = specificTermNode, ///
+              variableNode = generalTermVariableNode, ///
+              variableIdentifier = variableNode.getVariableIdentifier();
 
         let context;
 
         context = generalContext; ///
 
-        const variable = Variable.fromVariableNode(variableNode, context);
+        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
 
         context = specificContext;  ///
 
-        const term = Term.fromTermNode(termNode, context);
+        const term = context.findTermByTermNode(termNode);
 
         termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
 
@@ -113,25 +115,26 @@ class MetaLevelUnifier extends Unifier {
       }
     },
     {
-      generalNodeQuery: declarationMetavariableNodeQuery,
-      specificNodeQuery: declarationMetavariableNodeQuery,
-      unify: (generalDeclarationMetavariableNode, specificDeclarationMetavariableNode, substitutions, generalContext, specificContext) => {
+      generalNodeQuery: assumptionMetavariableNodeQuery,
+      specificNodeQuery: assumptionMetavariableNodeQuery,
+      unify: (generalAssumptionMetavariableNode, specificAssumptionMetavariableNode, substitutions, generalContext, specificContext) => {
         let referenceUnifies;
 
-        const { Metavariable, Reference } = ontology;
+        const { Reference } = ontology;
 
         let context,
             metavariableNode;
 
         context = generalContext; ///
 
-        metavariableNode = generalDeclarationMetavariableNode;  ///
+        metavariableNode = generalAssumptionMetavariableNode;  ///
 
-        const metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);  ///
+        const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+              metavariable = context.findMetavariableByMetavariableName(metavariableName);
 
         context = specificContext;  ///
 
-        metavariableNode = specificDeclarationMetavariableNode; ///
+        metavariableNode = specificAssumptionMetavariableNode; ///
 
         const reference = Reference.fromMetavariableNode(metavariableNode, context);
 

package/src/utilities/brackets.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import ontology from "../ontology";
-import LocalContext from "../context/local";
+import TemporaryContext from "../context/temporary";
 import combinatorBracketedContext from "../context/bracketed/combinator";
 import constructorBracketedContext from "../context/bracketed/constructor";
 
@@ -21,22 +21,6 @@ export function stripBracketsFromTerm(term, context) {
   return term;
 }
 
-export function stripBracketsFromReference(reference, context) {
-  const referenceNode = reference.getNode(),
-    bracketedReferenceChildNode = bracketedReferenceChildNodeFromReferenceNode(referenceNode);
-
-  if (bracketedReferenceChildNode !== null) {
-    context = contextFromReference(reference, context); ///
-
-    const { Reference } = ontology,
-          referenceNode = bracketedReferenceChildNode;  ///
-
-    reference = Reference.fromReferenceNode(referenceNode, context);
-  }
-
-  return reference;
-}
-
 export function stripBracketsFromStatement(statement, context) {
   const statementNode = statement.getNode(),
         bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
@@ -105,22 +89,12 @@ export function bracketedStatementChildNodeFromStatementNode(statementNode) {
   return bracketedStatementChildNode;
 }
 
-function contextFromReference(reference, context) {
-  const referenceTokens = reference.getTokens(),
-        tokens = referenceTokens, ///
-        localContext = LocalContext.fromContextAndTokens(context, tokens);
-
-  context = localContext; ///
-
-  return context;
-}
-
 function contextFromStatement(statement, context) {
   const statementTokens = statement.getTokens(),
         tokens = statementTokens, ///
-        localContext = LocalContext.fromContextAndTokens(context, tokens);
+        temporaryContext = TemporaryContext.fromContextAndTokens(context, tokens);
 
-  context = localContext; ///
+  context = temporaryContext; ///
 
   return context;
 }

package/src/utilities/context.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import ontology from "../ontology";
-import LocalContext from "../context/local";
+import TemporaryContext from "../context/temporary";
 
 export function metavariableFromFrame(frame, context) {
   context = contextFromFrame(frame, context); ///
@@ -106,9 +106,9 @@ export function satisfiesAssertionFromStatement(statement, context) {
 function contextFromFrame(frame, context) {
   const frameTokens = frame.getTokens(),
         tokens = frameTokens, ///
-        localContext = LocalContext.fromContextAndTokens(context, tokens);
+        temporaryContext = TemporaryContext.fromContextAndTokens(context, tokens);
 
-  context = localContext; ///
+  context = temporaryContext; ///
 
   return context;
 }
@@ -116,9 +116,9 @@ function contextFromFrame(frame, context) {
 function contextFromStatement(statement, context) {
   const statementTokens = statement.getTokens(),
         tokens = statementTokens, ///
-        localContext = LocalContext.fromContextAndTokens(context, tokens);
+        temporaryContext = TemporaryContext.fromContextAndTokens(context, tokens);
 
-  context = localContext; ///
+  context = temporaryContext; ///
 
   return 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/json.js

@@ -203,6 +203,22 @@ export function labelFromJSON(json, context) {
   return label;
 }
 
+export function framesFromJSON(json, context) {
+  let { frames } = json;
+
+  const { Frame } = ontology,
+        framesJSON = frames; ///
+
+  frames = framesJSON.map((frameJSON) => {
+    const json = frameJSON,  ///
+          frame = Frame.fromJSON(json, context);
+
+    return frame;
+  });
+
+  return frames;
+}
+
 export function labelsFromJSON(json, context) {
   let { labels } = json;
 
@@ -600,6 +616,18 @@ export function rulesToRulesJSON(rules) {
   return rulesJSON;
 }
 
+export function framesToFramesJSON(frames) {
+  const framesJSON = frames.map((frame) => {
+    const frameJSON = frame.toJSON();
+
+    frame = frameJSON; ///
+
+    return frame;
+  });
+
+  return framesJSON;
+}
+
 export function labelsToLabelsJSON(labels) {
   const labelsJSON = labels.map((label) => {
     const labelJSON = label.toJSON();

package/src/utilities/metavariable.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+
+const metavariableNameNodeQuery = nodeQuery("/metavariable/@name!");
+
+export function metavariableNameFromMetavariableNode(metavariableNode) {
+  const metavariableNameTerminalNode = metavariableNameNodeQuery(metavariableNode),
+        metavariableNameTerminalNodeContent = metavariableNameTerminalNode.getContent(),
+        metavariableName = metavariableNameTerminalNodeContent; ///
+
+  return metavariableName;
+}

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,27 +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,
-            termSubstitution = TermSubstitution.fromStatementNode(statementNode, context),
-            frameSubstitution = FrameSubstitution.fromStatementNode(statementNode, context);
+      const statementMetavariableName = statementMetavariableNameFromFrameNode(statementNode),
+            metavariableName = statementMetavariableName, ///
+            metavariable = generalContext.findMetavariableByMetavariableName(metavariableName);
 
-      substitution = (termSubstitution || frameSubstitution);
+      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();
+        }
       }
     }
   }