diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/logical/SolverLogical.java b/reactor/API/src/jetbrains/mps/logic/reactor/logical/JoinableLogical.java
similarity index 67%
rename from reactor/API/src/jetbrains/mps/logic/reactor/logical/SolverLogical.java
rename to reactor/API/src/jetbrains/mps/logic/reactor/logical/JoinableLogical.java
index e244e98f..184be403 100644
--- a/reactor/API/src/jetbrains/mps/logic/reactor/logical/SolverLogical.java
+++ b/reactor/API/src/jetbrains/mps/logic/reactor/logical/JoinableLogical.java
@@ -8,25 +8,25 @@ package jetbrains.mps.logic.reactor.logical;
  *
  * @param <T> the value type
  */
-public interface SolverLogical<T> extends Logical<T> {
+public interface JoinableLogical<T> extends Logical<T> {
 
   /**
    * Covariant override.
    */
-  SolverLogical<T> findRoot();
+  JoinableLogical<T> findRoot();
 
   /**
    * Unions two equivalence classes of logicals. 
    * Both the receiver and the {@code other} parameter are expected to be representatives.
    * The one with the highest rank becomes the representative for the new class.
    */
-  void union(SolverLogical<T> other, SolverLogical.ValueReconciler<T> reconciler);
+  void union(JoinableLogical<T> other, JoinableLogical.ValueReconciler<T> reconciler);
 
   /**
-   * Calls {@link jetbrains.mps.logic.reactor.logical.SolverLogical#union(SolverLogical<T>, SolverLogical.ValueReconciler<T>) } with the default value reconciler.
+   * Calls {@link JoinableLogical#union(JoinableLogical <T>, JoinableLogical.ValueReconciler<T>) } with the default value reconciler.
    * The default reconciler throws {@link java.lang.IllegalArgumentException } if the two values are not equal.
    */
-  void union(SolverLogical<T> other);
+  void union(JoinableLogical<T> other);
 
   /**
    * Should only be called on a representative. 
diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/MemEvaluationSession.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/EvaluationSessionImpl.kt
similarity index 95%
rename from reactor/Core/src/jetbrains/mps/logic/reactor/core/MemEvaluationSession.kt
rename to reactor/Core/src/jetbrains/mps/logic/reactor/core/EvaluationSessionImpl.kt
index 2fc062da..65a12a14 100644
--- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/MemEvaluationSession.kt
+++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/EvaluationSessionImpl.kt
@@ -21,7 +21,7 @@ interface SessionObjects {
 
 }
 
-class MemEvaluationSession private constructor (
+class EvaluationSessionImpl private constructor (
     val program: Program,
     val sessionSolver: SessionSolver,
     val trace: EvaluationTrace) : EvaluationSession(), SessionObjects
@@ -72,7 +72,7 @@ class MemEvaluationSession private constructor (
                 parameters.get("profiling.data") as MutableMap<String, String>?
             val profiler = durations?.let { Profiler() }
 
-            session = MemEvaluationSession(program, sessionSolver, evaluationTrace)
+            session = EvaluationSessionImpl(program, sessionSolver, evaluationTrace)
             ourBackend.ourSession.set(session)
             try {
                 session.launch(parameters["main"] as Constraint, profiler, storeView)
@@ -109,7 +109,7 @@ class MemEvaluationSession private constructor (
 
     private class Backend : EvaluationSession.Backend {
 
-        val ourSession = ThreadLocal<MemEvaluationSession>()
+        val ourSession = ThreadLocal<EvaluationSessionImpl>()
 
         override fun current(): EvaluationSession = ourSession.get() ?: throw IllegalStateException("no session")
 
diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/Logical.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/Logical.kt
index 6444246c..2faac1d7 100644
--- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/Logical.kt
+++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/Logical.kt
@@ -3,7 +3,7 @@ package jetbrains.mps.logic.reactor.core
 
 import jetbrains.mps.logic.reactor.logical.Logical
 import jetbrains.mps.logic.reactor.logical.MetaLogical
-import jetbrains.mps.logic.reactor.logical.SolverLogical
+import jetbrains.mps.logic.reactor.logical.JoinableLogical
 import java.util.*
 
 /**
@@ -19,20 +19,20 @@ interface LogicalObserver {
 }
 
 fun Logical<*>.addObserver(observer: LogicalObserver) {
-    (this as MemLogical<*>).valueObservers.add(this.to(observer))
-    (this as MemLogical<*>).parentObservers.add(this.to(observer))
+    (this as LogicalImpl<*>).valueObservers.add(this.to(observer))
+    (this as LogicalImpl<*>).parentObservers.add(this.to(observer))
 }
 
 fun Logical<*>.removeObserver(observer: LogicalObserver) {
-    (this as MemLogical<*>).valueObservers.removeAll { p -> p.second == observer }
-    (this as MemLogical<*>).parentObservers.removeAll { p -> p.second == observer }
+    (this as LogicalImpl<*>).valueObservers.removeAll { p -> p.second == observer }
+    (this as LogicalImpl<*>).parentObservers.removeAll { p -> p.second == observer }
 }
 
-fun <V> MetaLogical<V>.logical(): Logical<V> = MemLogical<V>(this)
+fun <V> MetaLogical<V>.logical(): Logical<V> = LogicalImpl<V>(this)
 
-fun <V> MetaLogical<V>.logical(value: V): Logical<V> = MemLogical<V>(name(), value)
+fun <V> MetaLogical<V>.logical(value: V): Logical<V> = LogicalImpl<V>(name(), value)
 
-class MemLogical<T> : SolverLogical<T> {
+class LogicalImpl<T> : JoinableLogical<T> {
 
     companion object {
         var lastIdx = 0
@@ -42,15 +42,15 @@ class MemLogical<T> : SolverLogical<T> {
 
     val metaLogical: MetaLogical<T>
 
-    var _parent: MemLogical<T>? = null
+    var _parent: LogicalImpl<T>? = null
 
     var _value: T? = null
 
     var rank = 0
 
-    internal val valueObservers = ArrayList<Pair<MemLogical<*>, LogicalObserver>>()
+    internal val valueObservers = ArrayList<Pair<LogicalImpl<*>, LogicalObserver>>()
 
-    internal val parentObservers = ArrayList<Pair<MemLogical<*>, LogicalObserver>>()
+    internal val parentObservers = ArrayList<Pair<LogicalImpl<*>, LogicalObserver>>()
 
     constructor(value: T) {
         this.name = "$${++lastIdx}"
@@ -84,7 +84,7 @@ class MemLogical<T> : SolverLogical<T> {
 
     override fun metaLogical(): MetaLogical<T> = metaLogical
 
-    override fun findRoot(): SolverLogical<T> = find()
+    override fun findRoot(): JoinableLogical<T> = find()
 
     override fun setValue(newValue: T) {
         if (_value !== newValue) {
@@ -93,9 +93,9 @@ class MemLogical<T> : SolverLogical<T> {
         }
     }
 
-    override fun union(other: SolverLogical<T>, reconciler: SolverLogical.ValueReconciler<T>) {
+    override fun union(other: JoinableLogical<T>, reconciler: JoinableLogical.ValueReconciler<T>) {
         val thisRepr = this.find()
-        val otherRepr = (other as MemLogical<T>).find()
+        val otherRepr = (other as LogicalImpl<T>).find()
 
         // invariant: thisRepr.rank > otherRepr.rank
         if (thisRepr.rank() < otherRepr.rank()) {
@@ -136,11 +136,11 @@ class MemLogical<T> : SolverLogical<T> {
         }
     }
 
-    override fun union(other: SolverLogical<T>) {
+    override fun union(other: JoinableLogical<T>) {
         union(other, { a, b -> if (a != b) throw IllegalStateException("$a does not equal to $b")})
     }
 
-    private fun find(): MemLogical<T> {
+    private fun find(): LogicalImpl<T> {
         val tmp = _parent
         if (tmp == null) return this
         else {
@@ -154,19 +154,19 @@ class MemLogical<T> : SolverLogical<T> {
 
     private fun incRank() { rank++ }
 
-    private fun setParent(parent: MemLogical<T>) {
+    private fun setParent(parent: LogicalImpl<T>) {
         this._parent = parent
         notifyParentUpdated()
     }
 
-    private fun mergeValueObservers(mergeFrom: SolverLogical<T>) {
-        val other = mergeFrom as MemLogical<T>
+    private fun mergeValueObservers(mergeFrom: JoinableLogical<T>) {
+        val other = mergeFrom as LogicalImpl<T>
         valueObservers.addAll(other.valueObservers)
         other.valueObservers.clear()
     }
 
-    private fun mergeParentObservers(mergeFrom: SolverLogical<T>) {
-        val other = mergeFrom as MemLogical<T>
+    private fun mergeParentObservers(mergeFrom: JoinableLogical<T>) {
+        val other = mergeFrom as LogicalImpl<T>
         parentObservers.addAll(other.parentObservers)
         other.parentObservers.clear()
     }
diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/Matcher.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/Matcher.kt
index ad7458d8..09a79c94 100644
--- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/Matcher.kt
+++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/Matcher.kt
@@ -66,7 +66,7 @@ class Match(val rule: Rule,
                         meta2logical[metaLogical] = when (value) {
                             is Logical<*>   -> value
                             is LogicalOwner -> value.logical()
-                            else            -> MemLogical(value)
+                            else            -> LogicalImpl(value)
                         }
                     } else {
                         meta2logical[metaLogical] = metaLogical.logical()
diff --git a/reactor/Test/src/solver/EqualsSolver.kt b/reactor/Test/src/solver/EqualsSolver.kt
index 23fa25bc..58a0243d 100644
--- a/reactor/Test/src/solver/EqualsSolver.kt
+++ b/reactor/Test/src/solver/EqualsSolver.kt
@@ -7,7 +7,7 @@ import jetbrains.mps.logic.reactor.evaluation.PredicateInvocation
 import jetbrains.mps.logic.reactor.logical.Logical
 import jetbrains.mps.logic.reactor.logical.LogicalContext
 import jetbrains.mps.logic.reactor.logical.MetaLogical
-import jetbrains.mps.logic.reactor.logical.SolverLogical
+import jetbrains.mps.logic.reactor.logical.JoinableLogical
 import jetbrains.mps.logic.reactor.program.Predicate
 import jetbrains.mps.logic.reactor.program.PredicateSymbol
 
@@ -22,11 +22,11 @@ class EqualsSolver  : AbstractSolver() {
     }
 
     private fun _ask(left: Any?, right: Any?): Boolean {
-        return if (left is SolverLogical<*> && right is SolverLogical<*>) {
+        return if (left is JoinableLogical<*> && right is JoinableLogical<*>) {
             ask_logical_logical(left, right)
-        } else if (left is SolverLogical<*>) {
+        } else if (left is JoinableLogical<*>) {
             ask_logical_value(left, right)
-        } else if (right is SolverLogical<*>) {
+        } else if (right is JoinableLogical<*>) {
             ask_value_logical(left, right)
         } else {
             ask_value_value(left, right)
@@ -38,27 +38,27 @@ class EqualsSolver  : AbstractSolver() {
     }
 
     private fun _tell(left: Any?, right: Any?) {
-        if (left is SolverLogical<*> && right is SolverLogical<*>) {
-            tell_logical_logical(left as SolverLogical<Any>, right as SolverLogical<Any>)
-        } else if (left is SolverLogical<*>) {
-            tell_logical_value(left as SolverLogical<Any>, right)
-        } else if (right is SolverLogical<*>) {
-            tell_value_logical(left, right as SolverLogical<Any>)
+        if (left is JoinableLogical<*> && right is JoinableLogical<*>) {
+            tell_logical_logical(left as JoinableLogical<Any>, right as JoinableLogical<Any>)
+        } else if (left is JoinableLogical<*>) {
+            tell_logical_value(left as JoinableLogical<Any>, right)
+        } else if (right is JoinableLogical<*>) {
+            tell_value_logical(left, right as JoinableLogical<Any>)
         } else {
             tell_value_value(left, right)
         }
     }
 
-    fun ask_logical_logical(left: SolverLogical<*>, right: SolverLogical<*>): Boolean {
+    fun ask_logical_logical(left: JoinableLogical<*>, right: JoinableLogical<*>): Boolean {
         if (left.findRoot() == right.findRoot()) return true
         return left.isBound && right.isBound && left.findRoot().value() == right.findRoot().value()
     }
 
-    fun ask_logical_value(left: SolverLogical<*>, right: Any?): Boolean {
+    fun ask_logical_value(left: JoinableLogical<*>, right: Any?): Boolean {
         return left.isBound && left.findRoot().value() == right
     }
 
-    fun ask_value_logical(left: Any?,  right: SolverLogical<*>): Boolean {
+    fun ask_value_logical(left: Any?,  right: JoinableLogical<*>): Boolean {
         return right.isBound && right.findRoot().value() == left
     }
 
@@ -66,7 +66,7 @@ class EqualsSolver  : AbstractSolver() {
         return left == right
     }
 
-    fun <T> tell_logical_logical(left: SolverLogical<T>, right: SolverLogical<T>) {
+    fun <T> tell_logical_logical(left: JoinableLogical<T>, right: JoinableLogical<T>) {
         if (left == right) return
 
         val leftRepr = left.findRoot()
@@ -77,7 +77,7 @@ class EqualsSolver  : AbstractSolver() {
         leftRepr.union(rightRepr, { a, b -> tell_value_value(a, b)})
     }
 
-    fun <T> tell_logical_value(left: SolverLogical<T>, right: T?) {
+    fun <T> tell_logical_value(left: JoinableLogical<T>, right: T?) {
         if (left.isBound) {
             check(left.findRoot().value() == right)
         }
@@ -86,7 +86,7 @@ class EqualsSolver  : AbstractSolver() {
         }
     }
 
-    fun <T> tell_value_logical(left: T?,  right: SolverLogical<T>) {
+    fun <T> tell_value_logical(left: T?,  right: JoinableLogical<T>) {
         if (right.isBound) {
             check(right.findRoot().value() == left)
         }
diff --git a/reactor/Test/test/LogicalHelper.kt b/reactor/Test/test/LogicalHelper.kt
index 9da12a6c..ee6971c8 100644
--- a/reactor/Test/test/LogicalHelper.kt
+++ b/reactor/Test/test/LogicalHelper.kt
@@ -1,5 +1,5 @@
 import jetbrains.mps.logic.reactor.core.LogicalObserver
-import jetbrains.mps.logic.reactor.core.MemLogical
+import jetbrains.mps.logic.reactor.core.LogicalImpl
 import jetbrains.mps.logic.reactor.evaluation.PredicateInvocation
 import jetbrains.mps.logic.reactor.logical.*
 import jetbrains.mps.logic.reactor.program.Predicate
@@ -11,14 +11,14 @@ import java.util.*
  */
 
 
-fun <T: Any> anon(value: T) = MemLogical(value)
+fun <T: Any> anon(value: T) = LogicalImpl(value)
 
-fun <T: Any> logical(name: String) = MemLogical<T>(name)
+fun <T: Any> logical(name: String) = LogicalImpl<T>(name)
 
-fun <T: Any> logical(name1: String, name2: String) = Pair(MemLogical<T>(name1), MemLogical<T>(name2))
+fun <T: Any> logical(name1: String, name2: String) = Pair(LogicalImpl<T>(name1), LogicalImpl<T>(name2))
 
 fun <T: Any> logical(name1: String, name2: String, name3: String) =
-    Triple(MemLogical<T>(name1), MemLogical<T>(name2), MemLogical<T>(name3))
+    Triple(LogicalImpl<T>(name1), LogicalImpl<T>(name2), LogicalImpl<T>(name3))
 
 inline fun <reified T: Any> metaLogical(name: String) = MetaLogical<T>(name, T::class.java)
 
@@ -36,7 +36,7 @@ fun <T: Any> Logical<T>.get(): T = findRoot().value()
 fun <T: Any> Logical<T>.getNullable(): T? = findRoot().value()
 
 fun <T: Any> Logical<T>.set(t: T) {
-    if (this is SolverLogical<T>)
+    if (this is JoinableLogical<T>)
         findRoot().setValue(t)
     else
         throw IllegalStateException("unexpected receiver $this")
diff --git a/reactor/Test/test/TestLogicalObserver.kt b/reactor/Test/test/TestLogicalObserver.kt
index 5865c193..71c1906a 100644
--- a/reactor/Test/test/TestLogicalObserver.kt
+++ b/reactor/Test/test/TestLogicalObserver.kt
@@ -1,5 +1,5 @@
 import jetbrains.mps.logic.reactor.core.LogicalObserver
-import jetbrains.mps.logic.reactor.core.MemLogical
+import jetbrains.mps.logic.reactor.core.LogicalImpl
 import jetbrains.mps.logic.reactor.core.addObserver
 import jetbrains.mps.logic.reactor.logical.Logical
 import org.junit.Test
diff --git a/reactor/Test/test/TestProgram.kt b/reactor/Test/test/TestProgram.kt
index 86089fc7..ea82ae35 100644
--- a/reactor/Test/test/TestProgram.kt
+++ b/reactor/Test/test/TestProgram.kt
@@ -1,4 +1,4 @@
-import jetbrains.mps.logic.reactor.core.MemEvaluationSession
+import jetbrains.mps.logic.reactor.core.EvaluationSessionImpl
 import jetbrains.mps.logic.reactor.evaluation.EvaluationSession
 import jetbrains.mps.logic.reactor.evaluation.StoreView
 import jetbrains.mps.logic.reactor.logical.Logical
@@ -19,10 +19,10 @@ class TestProgram {
 
     companion object {
         @BeforeClass @JvmStatic fun setup() {
-            MemEvaluationSession.init();
+            EvaluationSessionImpl.init();
         }
         @AfterClass @JvmStatic fun teardown() {
-            MemEvaluationSession.deinit();
+            EvaluationSessionImpl.deinit();
         }
     }