123 files changed, 8065 insertions, 1545 deletions
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/.classpath b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/.classpath
index de68b5f7..25b7f16f 100644
--- a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/.classpath
+++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/.classpath
@@ -1,11 +1,15 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
+<classpath>
-        <classpathentry kind="src" path="xtend-gen"/>
+        <classpathentry kind="src" path="xtend-gen"/>
-        <classpathentry kind="src" path="queries"/>
+        <classpathentry kind="src" path="queries"/>
-        <classpathentry kind="src" path="vql-gen"/>
+        <classpathentry kind="src" path="vql-gen"/>
-        <classpathentry exported="true" kind="lib" path="lib/alloy4.2_2015-02-22.jar"/>
+        <classpathentry exported="true" kind="lib" path="lib/alloy4.2_2015-02-22.jar"/>
-        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
-        <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+        <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
-        <classpathentry kind="src" path="src"/>
+        <classpathentry kind="src" path="src">
-        <classpathentry kind="output" path="bin"/>
+                <attributes>
-</classpath>
+                        <attribute name="org.eclipse.jdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY" value="hu.bme.mit.inf.dlsreasoner.alloy.reasoner/lib"/>
+                </attributes>
+        </classpathentry>
+        <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/META-INF/MANIFEST.MF b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/META-INF/MANIFEST.MF
index b944302b..75581def 100644
--- a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/META-INF/MANIFEST.MF
+++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/META-INF/MANIFEST.MF
@@ -20,7 +20,8 @@ Require-Bundle: com.google.guava,
 org.eclipse.viatra.query.runtime.base.itc;bundle-version="1.3.0",
 hu.bme.mit.inf.dslreasoner.ecore2logic;bundle-version="1.0.0",
 org.eclipse.viatra.query.runtime;bundle-version="2.0.0"
-Import-Package: org.apache.log4j;version="1.2.15"
-Automatic-Module-Name: hu.bme.mit.inf.dlsreasoner.alloy.reasoner
-Bundle-ActivationPolicy: lazy
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Bundle-ActivationPolicy: lazy
+Bundle-NativeCode: libminisat.so;osname=Linux;processor=x86_64
+Automatic-Module-Name: hu.bme.mit.inf.dlsreasoner.alloy.reasoner
+Import-Package: org.apache.log4j;version="1.2.15"
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/AlloySolver.xtend b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/AlloySolver.xtend
index f6b0b4a5..1eb6442b 100644
--- a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/AlloySolver.xtend
+++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/AlloySolver.xtend
@@ -62,7 +62,7 @@ class AlloySolver extends LogicReasoner{
                val result2 = handler.callSolver(alloyProblem,workspace,alloyConfig,alloyCode)
                alloyConfig.progressMonitor.workedSearchFinished
                
-                val logicResult = backwardMapper.transformOutput(problem,configuration.solutionScope.numberOfRequiredSolution,result2,forwardTrace,transformationTime)
+                val logicResult = backwardMapper.transformOutput(problem,configuration.solutionScope.numberOfRequiredSolutions,result2,forwardTrace,transformationTime)
                alloyConfig.progressMonitor.workedBackwardTransformationFinished
                //val solverFinish = System.currentTimeMillis-solverStart
                // Finish: Solving Alloy problem
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/Alloy2LogicMapper.xtend b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/Alloy2LogicMapper.xtend
index 2efd6b29..328ca176 100644
--- a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/Alloy2LogicMapper.xtend
+++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/Alloy2LogicMapper.xtend
@@ -9,7 +9,7 @@ class Alloy2LogicMapper {
        public def transformOutput(LogicProblem problem, int requiredNumberOfSolution, MonitoredAlloySolution monitoredAlloySolution, Logic2AlloyLanguageMapperTrace trace, long transformationTime) {
                val models = monitoredAlloySolution.aswers.map[it.key].toList
                
-                if(!monitoredAlloySolution.finishedBeforeTimeout) {
+                if(models.empty || !monitoredAlloySolution.finishedBeforeTimeout) {
                        return createInsuficientResourcesResult => [
                                it.problem = problem
                                it.representation += models
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/AlloyHandler.xtend b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/AlloyHandler.xtend
index 9b4265b9..451aad6e 100644
--- a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/AlloyHandler.xtend
+++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/AlloyHandler.xtend
@@ -101,15 +101,8 @@ class AlloyHandler {
                        try{
                                answers = future.get(configuration.runtimeLimit,TimeUnit.SECONDS)
                                finished = true
-                        } catch (TimeoutException ex) {
+                        } catch (TimeoutException | InterruptedException | ExecutionException e) {
-                                // handle the timeout
+                                future.cancel(true)
-                        } catch (InterruptedException e) {
-                                // handle the interrupts
-                        } catch (ExecutionException e) {
-                                // handle other exceptions
-                        } finally {
-                                future.cancel(true);
-                                
                                answers = callable.partialAnswers
                                finished = false
                        }
@@ -195,7 +188,7 @@ class AlloyCallerWithTimeout implements Callable<List<Pair<A4Solution,Long>>>{
                                        } else {
                                                lastAnswer = lastAnswer.next
                                        }
-                                        configuration.progressMonitor.workedBackwardTransformation(configuration.solutionScope.numberOfRequiredSolution)
+                                        configuration.progressMonitor.workedBackwardTransformation(configuration.solutionScope.numberOfRequiredSolutions)
                                        
                                        val runtime = System.currentTimeMillis -startTime
                                        synchronized(this) {
@@ -212,8 +205,8 @@ class AlloyCallerWithTimeout implements Callable<List<Pair<A4Solution,Long>>>{
        }
        
        def hasEnoughSolution(List<?> answers) {
-                if(configuration.solutionScope.numberOfRequiredSolution < 0) return false
+                if(configuration.solutionScope.numberOfRequiredSolutions < 0) return false
-                else return answers.size() == configuration.solutionScope.numberOfRequiredSolution
+                else return answers.size() == configuration.solutionScope.numberOfRequiredSolutions
        }
        
        public def getPartialAnswers() {
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/RunCommandMapper.xtend b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/RunCommandMapper.xtend
index 494197bc..b74017d8 100644
--- a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/RunCommandMapper.xtend
+++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/RunCommandMapper.xtend
@@ -9,8 +9,12 @@ import hu.bme.mit.inf.dslreasoner.alloyLanguage.ALSString
 import hu.bme.mit.inf.dslreasoner.alloyLanguage.ALSTerm
 import hu.bme.mit.inf.dslreasoner.alloyLanguage.AlloyLanguageFactory
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicSolverConfiguration
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition
 import java.util.List
+import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
 class RunCommandMapper {
        val extension AlloyLanguageFactory factory = AlloyLanguageFactory.eINSTANCE
        val Logic2AlloyLanguageMapper_Support support = new Logic2AlloyLanguageMapper_Support;
@@ -89,16 +93,18 @@ class RunCommandMapper {
                ]
                
                for(upperLimit : config.typeScopes.maxNewElementsByType.entrySet) {
-                        val limit = upperLimit.value
+                        val type = upperLimit.key
+                        val limit = upperLimit.value + getExistingCount(type)
                        if(limit != LogicSolverConfiguration::Unlimited) {
-                                this.typeScopeMapping.addUpperMultiplicity(specification,upperLimit.key,limit,mapper,trace)
+                                this.typeScopeMapping.addUpperMultiplicity(specification,type,limit,mapper,trace)
                        }
                }
                
                for(lowerLimit : config.typeScopes.minNewElementsByType.entrySet) {
-                        val limit = lowerLimit.value
+                        val type = lowerLimit.key
+                        val limit = lowerLimit.value + getExistingCount(type)
                        if(limit != 0) {
-                                this.typeScopeMapping.addLowerMultiplicity(specification,lowerLimit.key,limit,mapper,trace)
+                                this.typeScopeMapping.addLowerMultiplicity(specification,type,limit,mapper,trace)
                        }
                }
                
@@ -106,6 +112,11 @@ class RunCommandMapper {
                setStringScope(specification,config,specification.runCommand)
        }
        
+        private def getExistingCount(Type type) {
+                val existing = type.transitiveClosureStar[it.subtypes].filter(TypeDefinition).map[elements].flatten.toSet
+                existing.size
+        }
+        
        protected def Boolean setStringScope(ALSDocument specification, AlloySolverConfiguration config, ALSRunCommand it) {
                if(config.typeScopes.maxNewStrings === LogicSolverConfiguration::Unlimited) {
                        throw new UnsupportedOperationException('''A string scope have to be specified for Alloy!''')
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language/.launch/Generate Language Infrastructure (hu.bme.mit.inf.dslreasoner.alloy.language).launch b/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language/.launch/Generate Language Infrastructure (hu.bme.mit.inf.dslreasoner.alloy.language).launch
deleted file mode 100644
index 77031bf1..00000000
--- a/Solvers/Alloy-Solver/hu.bme.mit.inf.dslreasoner.alloy.language/.launch/Generate Language Infrastructure (hu.bme.mit.inf.dslreasoner.alloy.language).launch
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<launchConfiguration type="org.eclipse.emf.mwe2.launch.Mwe2LaunchConfigurationType">
-<stringAttribute key="org.eclipse.debug.core.ATTR_REFRESH_SCOPE" value="${working_set:&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;&#10;&lt;launchConfigurationWorkingSet factoryID=&quot;org.eclipse.ui.internal.WorkingSetFactory&quot; id=&quot;1299248699643_13&quot; label=&quot;working set&quot; name=&quot;working set&quot;&gt;&#10;&lt;item factoryID=&quot;org.eclipse.ui.internal.model.ResourceFactory&quot; path=&quot;/hu.bme.mit.inf.dslreasoner.alloy.language&quot; type=&quot;4&quot;/&gt;&#10;&lt;item factoryID=&quot;org.eclipse.ui.internal.model.ResourceFactory&quot; path=&quot;/hu.bme.mit.inf.dslreasoner.alloy.language.generator&quot; type=&quot;4&quot;/&gt;&#10;&lt;item factoryID=&quot;org.eclipse.ui.internal.model.ResourceFactory&quot; path=&quot;/hu.bme.mit.inf.dslreasoner.alloy.language.tests&quot; type=&quot;4&quot;/&gt;&#10;&lt;item factoryID=&quot;org.eclipse.ui.internal.model.ResourceFactory&quot; path=&quot;/hu.bme.mit.inf.dslreasoner.alloy.language.ui&quot; type=&quot;4&quot;/&gt;&#10;&lt;/launchConfigurationWorkingSet&gt;}"/>
-<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
-<listEntry value="/hu.bme.mit.inf.dslreasoner.alloy.language"/>
-</listAttribute>
-<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
-<listEntry value="4"/>
-</listAttribute>
-<listAttribute key="org.eclipse.debug.ui.favoriteGroups">
-<listEntry value="org.eclipse.debug.ui.launchGroup.debug"/>
-<listEntry value="org.eclipse.debug.ui.launchGroup.run"/>
-</listAttribute>
-<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher"/>
-<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="src/hu/bme/mit/inf/dslreasoner/GenerateAlloyLanguage.mwe2"/>
-<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="hu.bme.mit.inf.dslreasoner.alloy.language"/>
-<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Xmx512m"/>
-</launchConfiguration>
diff --git a/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/.classpath b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/.classpath
new file mode 100644
index 00000000..e19039ae
--- /dev/null
+++ b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/.classpath
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER">
+                <attributes>
+                        <attribute name="module" value="true"/>
+                </attributes>
+        </classpathentry>
+        <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+        <classpathentry kind="src" path="src">
+                <attributes>
+                        <attribute name="org.eclipse.jdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY" value="hu.bme.mit.inf.dslreasoner.ilp.cbc/lib"/>
+                </attributes>
+        </classpathentry>
+        <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/.gitignore b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/.gitignore
new file mode 100644
index 00000000..0cc6a59e
--- /dev/null
+++ b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/.gitignore
@@ -0,0 +1,2 @@
+/bin/
+/cpp/build/
diff --git a/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/.project b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/.project
new file mode 100644
index 00000000..6c32e464
--- /dev/null
+++ b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+        <name>hu.bme.mit.inf.dslreasoner.ilp.cbc</name>
+        <comment></comment>
+        <projects>
+        </projects>
+        <buildSpec>
+                <buildCommand>
+                        <name>org.eclipse.jdt.core.javabuilder</name>
+                        <arguments>
+                        </arguments>
+                </buildCommand>
+                <buildCommand>
+                        <name>org.eclipse.pde.ManifestBuilder</name>
+                        <arguments>
+                        </arguments>
+                </buildCommand>
+                <buildCommand>
+                        <name>org.eclipse.pde.SchemaBuilder</name>
+                        <arguments>
+                        </arguments>
+                </buildCommand>
+        </buildSpec>
+        <natures>
+                <nature>org.eclipse.pde.PluginNature</nature>
+                <nature>org.eclipse.jdt.core.javanature</nature>
+        </natures>
+</projectDescription>
diff --git a/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/META-INF/MANIFEST.MF b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/META-INF/MANIFEST.MF
new file mode 100644
index 00000000..04478746
--- /dev/null
+++ b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/META-INF/MANIFEST.MF
@@ -0,0 +1,10 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Cbc
+Bundle-SymbolicName: hu.bme.mit.inf.dslreasoner.ilp.cbc
+Bundle-Version: 1.0.0.qualifier
+Automatic-Module-Name: hu.bme.mit.inf.dslreasoner.ilp.cbc
+Export-Package: hu.bme.mit.inf.dslreasoner.ilp.cbc
+Bundle-NativeCode: libviatracbc.so;
+ osname=Linux;
+ processor=x86_64
diff --git a/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/build.properties b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/build.properties
new file mode 100644
index 00000000..34d2e4d2
--- /dev/null
+++ b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/build.properties
@@ -0,0 +1,4 @@
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .
diff --git a/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/cpp/CMakeLists.txt b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/cpp/CMakeLists.txt
new file mode 100644
index 00000000..6169ae8f
--- /dev/null
+++ b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/cpp/CMakeLists.txt
@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.10.2)
+project(hu.bme.mit.inf.dslreasoner.ilp.cbc)
+set(CMAKE_CXX_STANDARD 14)
+find_package(JNI REQUIRED)
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(CBC REQUIRED cbc)
+add_library(viatracbc SHARED viatracbc.cpp)
+target_link_libraries(viatracbc
+    ${JAVA_JVM_LIBRARY}
+    ${CBC_LIBRARIES})
+target_include_directories(viatracbc
+    PUBLIC ${JNI_INCLUDE_DIRS}
+    PRIVATE ${CBC_INCLUDE_DIRS})
+set(VIATRACBC_NATIVES_DIR ${CMAKE_SOURCE_DIR}/../lib)
+add_custom_command(TARGET viatracbc POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E make_directory ${VIATRACBC_NATIVES_DIR}
+    COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:viatracbc> ${VIATRACBC_NATIVES_DIR})
diff --git a/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/cpp/viatracbc.cpp b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/cpp/viatracbc.cpp
new file mode 100644
index 00000000..34cab1dd
--- /dev/null
+++ b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/cpp/viatracbc.cpp
@@ -0,0 +1,277 @@
+#include <cmath>
+#include <cstdlib>
+#include <iostream>
+#include <stdexcept>
+#include <jni.h>
+#include "CbcBranchDefaultDecision.hpp"
+#include "CbcCompareDefault.hpp"
+#include "CbcHeuristic.hpp"
+#include "CbcHeuristicLocal.hpp"
+#include "CbcModel.hpp"
+#include "CglClique.hpp"
+#include "CglFlowCover.hpp"
+#include "CglGomory.hpp"
+#include "CglKnapsackCover.hpp"
+#include "CglMixedIntegerRounding.hpp"
+#include "CglOddHole.hpp"
+#include "CglProbing.hpp"
+#include "CoinModel.hpp"
+#include "OsiClpSolverInterface.hpp"
+#include "viatracbc.hpp"
+static const char *const kCbcExceptionClassName = "hu/bme/mit/inf/dslreasoner/ilp/cbc/CbcException";
+static const char *const kRuntimeExceptionClassName = "java/lang/RuntimeException";
+static const jint kCbcSolutionBounded = 0;
+static const jint kCbcSolutionUnbounded = 1;
+static const jint kCbcUnsat = 2;
+static const jint kCbcAbandoned = 3;
+static const jint kCbcTimeout = 4;
+static const jint kCbcError = 5;
+static CoinModel CreateModel(JNIEnv *env, jdoubleArray columnLowerBoundsArray,
+    jdoubleArray columnUpperBoundsArray, jintArray rowStartsArray, jintArray columnIndicesArray,
+    jdoubleArray entriedArray, jdoubleArray rowLowerBoundsArray, jdoubleArray rowUpperBoundsArray,
+    jdoubleArray objectiveArray, jboolean lpRelaxation);
+static void CreateModelColumns(JNIEnv *env, jdoubleArray columnLowerBoundsArray,
+    jdoubleArray columnUpperBoundsArray, jdoubleArray objectiveArray, jboolean lpRelaxation,
+    CoinModel &build);
+static void CreateModelRows(JNIEnv *env, jintArray rowStartsArray, jintArray columnIndicesArray,
+    jdoubleArray entriesArray, jdoubleArray rowLowerBoundsArray, jdoubleArray rowUpperBoundsArray,
+    CoinModel &build);
+static jint SolveModel(CoinModel &build, jdouble timeoutSeconds, jboolean silent, jdouble &value);
+static void ThrowException(JNIEnv *env, const char *message);
+template <
+    typename Array,
+    typename Element,
+    Element *(JNIEnv::*GetElementsPtr)(Array, jboolean *),
+    void (JNIEnv::*ReleaseElementsPtr)(Array, Element *, jint)
+>
+class PinnedArray {
+public:
+    PinnedArray(JNIEnv *env, Array array)
+        : env_{env}, array_{array}, elements_{(env->*GetElementsPtr)(array, nullptr)} {
+        if (elements_ == nullptr) {
+            throw std::runtime_error("Failed to pin array elements");
+        }
+    }
+    PinnedArray(const PinnedArray &) = delete;
+    PinnedArray(PinnedArray &&) = delete;
+    PinnedArray &operator=(const PinnedArray &) = delete;
+    PinnedArray &operator=(PinnedArray &&) = delete;
+    ~PinnedArray() {
+        (env_->*ReleaseElementsPtr)(array_, elements_, 0);
+    }
+    operator Element *() { return elements_; }
+    operator const Element *() const { return elements_; }
+private:
+    JNIEnv *env_;
+    Array array_;
+    Element *elements_;
+};
+using PinnedIntArray = PinnedArray<jintArray, jint, &JNIEnv::GetIntArrayElements, &JNIEnv::ReleaseIntArrayElements>;
+using PinnedDoubleArray = PinnedArray<jdoubleArray, jdouble, &JNIEnv::GetDoubleArrayElements, &JNIEnv::ReleaseDoubleArrayElements>;
+jint Java_hu_bme_mit_inf_dslreasoner_ilp_cbc_CbcSolver_solveIlpProblem(
+    JNIEnv *env, jclass klazz, jdoubleArray columnLowerBoundsArray, jdoubleArray columnUpperBoundsArray,
+    jintArray rowStartsArray, jintArray columnIndicesArray, jdoubleArray entriesArray,
+    jdoubleArray rowLowerBoundsArray, jdoubleArray rowUpperBoundsArray, jdoubleArray objectiveArray,
+    jdoubleArray outputArray, jboolean lpRelaxation, jdouble timeoutSeconds, jboolean silent) {
+    try {
+        auto build = CreateModel(env, columnLowerBoundsArray, columnUpperBoundsArray,
+            rowStartsArray, columnIndicesArray, entriesArray, rowLowerBoundsArray, rowUpperBoundsArray,
+            objectiveArray, lpRelaxation);
+        double value;
+        jint result = SolveModel(build, timeoutSeconds, silent, value);
+        if (result == kCbcSolutionBounded) {
+            PinnedDoubleArray output{env, outputArray};
+            *output = value;
+        }
+        return result;
+    } catch (const std::exception &e) {
+        ThrowException(env, e.what());
+    } catch (...) {
+        ThrowException(env, "Unknown solver error");
+    }
+    return kCbcError;
+}
+CoinModel CreateModel(JNIEnv *env, jdoubleArray columnLowerBoundsArray,
+    jdoubleArray columnUpperBoundsArray, jintArray rowStartsArray, jintArray columnIndicesArray,
+    jdoubleArray entriesArray, jdoubleArray rowLowerBoundsArray, jdoubleArray rowUpperBoundsArray,
+    jdoubleArray objectiveArray, jboolean lpRelaxation) {
+    CoinModel build;
+    CreateModelColumns(env, columnLowerBoundsArray, columnUpperBoundsArray, objectiveArray,
+        lpRelaxation, build);
+    CreateModelRows(env, rowStartsArray, columnIndicesArray, entriesArray, rowLowerBoundsArray,
+        rowUpperBoundsArray, build);
+    return build;
+}
+void CreateModelColumns(JNIEnv *env, jdoubleArray columnLowerBoundsArray,
+    jdoubleArray columnUpperBoundsArray, jdoubleArray objectiveArray, jboolean lpRelaxation,
+    CoinModel &build) {
+    int numColumns = env->GetArrayLength(columnLowerBoundsArray);
+    PinnedDoubleArray columnLowerBounds{env, columnLowerBoundsArray};
+    PinnedDoubleArray columnUpperBounds{env, columnUpperBoundsArray};
+    PinnedDoubleArray objective{env, objectiveArray};
+    for (int i = 0; i < numColumns; i++) {
+        build.setColumnBounds(i, columnLowerBounds[i], columnUpperBounds[i]);
+        build.setObjective(i, objective[i]);
+        if (!lpRelaxation) {
+            build.setInteger(i);
+        }
+    }
+}
+void CreateModelRows(JNIEnv *env, jintArray rowStartsArray, jintArray columnIndicesArray,
+    jdoubleArray entriesArray, jdoubleArray rowLowerBoundsArray, jdoubleArray rowUpperBoundsArray,
+    CoinModel &build) {
+    int numRows = env->GetArrayLength(rowLowerBoundsArray);
+    PinnedIntArray rowStarts{env, rowStartsArray};
+    PinnedIntArray columnIndices{env, columnIndicesArray};
+    PinnedDoubleArray entries{env, entriesArray};
+    PinnedDoubleArray rowLowerBounds{env, rowLowerBoundsArray};
+    PinnedDoubleArray rowUpperBounds{env, rowUpperBoundsArray};
+    for (int i = 0; i < numRows; i++) {
+        int rowStart = rowStarts[i];
+        int numbersInRow = rowStarts[i + 1] - rowStart;
+        build.addRow(numbersInRow, &columnIndices[rowStart], &entries[rowStart],
+            rowLowerBounds[i], rowUpperBounds[i]);
+    }
+}
+jint SolveModel(CoinModel &build, jdouble timeoutSeconds, jboolean silent, jdouble &value) {
+    OsiClpSolverInterface solver;
+    solver.loadFromCoinModel(build);
+    CbcModel model{solver};
+    if (timeoutSeconds >= 0) {
+        model.setDblParam(CbcModel::CbcMaximumSeconds, timeoutSeconds);
+    }
+    if (silent == JNI_FALSE) {
+        model.messageHandler()->setLogLevel(2);
+        model.solver()->messageHandler()->setLogLevel(1);
+    } else {
+        model.solver()->setHintParam(OsiDoReducePrint, true, OsiHintTry);
+        model.messageHandler()->setLogLevel(0);
+        model.solver()->messageHandler()->setLogLevel(0);
+    }
+    
+    // Cut generators and heuristics are used according to
+    // https://github.com/coin-or/Cbc/blob/6b977b6707f1755520c64fea57b95891c1f3ddc0/Cbc/examples/sample2.cpp
+    CglProbing probing;
+    probing.setUsingObjective(true);
+    probing.setMaxPass(1);
+    probing.setMaxPassRoot(5);
+    probing.setMaxProbe(10);
+    probing.setMaxProbeRoot(1000);
+    probing.setMaxLook(50);
+    probing.setMaxLookRoot(500);
+    probing.setMaxElements(200);
+    probing.setRowCuts(3);
+    model.addCutGenerator(&probing, -1, "Probing");
+    CglGomory gomory;
+    gomory.setLimit(300);
+    model.addCutGenerator(&gomory, -1, "Gomory");
+    CglKnapsackCover knapsackCover;
+    model.addCutGenerator(&knapsackCover, -1, "KnapsackCover");
+    CglClique clique;
+    clique.setStarCliqueReport(false);
+    clique.setRowCliqueReport(false);
+    model.addCutGenerator(&clique, -1, "Clique");
+    CglFlowCover flowCover;
+    model.addCutGenerator(&flowCover, -1, "FlowCover");
+    CglMixedIntegerRounding mixedIntegerRounding;
+    model.addCutGenerator(&mixedIntegerRounding, -1, "MixedIntegerRounding");
+    OsiClpSolverInterface *osiClp = dynamic_cast<OsiClpSolverInterface *>(model.solver());
+    if (osiClp != nullptr) {
+        osiClp->setSpecialOptions(128);
+        osiClp->setupForRepeatedUse(0, 0);
+    }
+    CbcRounding rounding;
+    model.addHeuristic(&rounding);
+    CbcHeuristicLocal localHeuristic;
+    model.addHeuristic(&localHeuristic);
+    CbcBranchDefaultDecision branchDecision;
+    model.setBranchingMethod(&branchDecision);
+    CbcCompareDefault nodeComparison;
+    model.setNodeComparison(nodeComparison);
+    model.initialSolve();
+    if (model.isInitialSolveProvenPrimalInfeasible()) {
+        return kCbcUnsat;
+    }
+    if (model.isInitialSolveProvenDualInfeasible()) {
+        return kCbcSolutionUnbounded;
+    }
+    if (model.isInitialSolveAbandoned()) {
+        return kCbcTimeout;
+    }
+    model.setMinimumDrop(CoinMin(1.0, fabs(model.getMinimizationObjValue()) * 1.0e-3 + 1.0e-4));
+    model.setMaximumCutPassesAtRoot(-100);
+    model.setNumberStrong(10);
+    model.solver()->setIntParam(OsiMaxNumIterationHotStart, 100);
+    model.branchAndBound();
+    switch (model.status()) {
+    case 0:
+        if (model.isProvenInfeasible()) {
+            return kCbcUnsat;
+        }
+        if (model.isProvenDualInfeasible()) {
+            return kCbcSolutionUnbounded;
+        }
+        if (model.isProvenOptimal()) {
+            value = model.getMinimizationObjValue();
+            return kCbcSolutionBounded;
+        }
+        throw std::runtime_error("CBC status is 0, but no solution is found");
+    case 1:
+        return kCbcTimeout;
+    case 2:
+        return kCbcAbandoned;
+    default:
+        throw std::runtime_error("Unknown CBC status");
+    }
+}
+void ThrowException(JNIEnv *env, const char *message) {
+    jclass exceptionClass = env->FindClass(kCbcExceptionClassName);
+    if (exceptionClass == nullptr) {
+        std::cerr << "WARNING: " << kCbcExceptionClassName << " class was not found" << std::endl;
+        exceptionClass = env->FindClass(kRuntimeExceptionClassName);
+        if (exceptionClass == nullptr) {
+            std::cerr << "FATAL: " << kRuntimeExceptionClassName << " class was not found" << std::endl;
+            std::cerr << "FATAL: " << message << std::endl;
+            std::exit(EXIT_FAILURE);
+        }
+    }
+    if (env->ThrowNew(exceptionClass, message) < 0) {
+        std::cerr << "FATAL: Could not throw java exception" << std::endl;
+        std::cerr << "FATAL: " << message << std::endl;
+        std::exit(EXIT_FAILURE);
+    }
+}
diff --git a/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/cpp/viatracbc.hpp b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/cpp/viatracbc.hpp
new file mode 100644
index 00000000..12198c8b
--- /dev/null
+++ b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/cpp/viatracbc.hpp
@@ -0,0 +1,16 @@
+#ifndef HU_BME_MIT_INF_DSLREASONER_ILP_CBC_
+#define HU_BME_MIT_INF_DSLREASONER_ILP_CBC_
+#include <jni.h>
+extern "C" {
+JNIEXPORT jint JNICALL Java_hu_bme_mit_inf_dslreasoner_ilp_cbc_CbcSolver_solveIlpProblem(
+    JNIEnv *env, jclass klazz, jdoubleArray columnLowerBoundsArray, jdoubleArray columnUpperBoundsArray,
+    jintArray rowStartsArray, jintArray columnIndicesArray, jdoubleArray entriesArray,
+    jdoubleArray rowLowerBoundsArray, jdoubleArray rowUpperBoundsArray, jdoubleArray objectiveArray,
+    jdoubleArray outputArray, jboolean lpRelaxation, jdouble timeoutSeconds, jboolean silent);
+}
+#endif // HU_BME_MIT_INF_DSLREASONER_ILP_CBC_
diff --git a/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/lib/libviatracbc.so b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/lib/libviatracbc.so
new file mode 100755
index 00000000..96289216
--- /dev/null
+++ b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/lib/libviatracbc.so
Binary files differ
diff --git a/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/src/hu/bme/mit/inf/dslreasoner/ilp/cbc/CbcException.java b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/src/hu/bme/mit/inf/dslreasoner/ilp/cbc/CbcException.java
new file mode 100644
index 00000000..26846958
--- /dev/null
+++ b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/src/hu/bme/mit/inf/dslreasoner/ilp/cbc/CbcException.java
@@ -0,0 +1,30 @@
+package hu.bme.mit.inf.dslreasoner.ilp.cbc;
+public class CbcException extends RuntimeException {
+        /**
+         * 
+         */
+        private static final long serialVersionUID = 2691773509078511887L;
+        public CbcException() {
+                super();
+        }
+        public CbcException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+                super(message, cause, enableSuppression, writableStackTrace);
+        }
+        public CbcException(String message, Throwable cause) {
+                super(message, cause);
+        }
+        public CbcException(String message) {
+                super(message);
+        }
+        public CbcException(Throwable cause) {
+                super(cause);
+        }
+}
diff --git a/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/src/hu/bme/mit/inf/dslreasoner/ilp/cbc/CbcResult.java b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/src/hu/bme/mit/inf/dslreasoner/ilp/cbc/CbcResult.java
new file mode 100644
index 00000000..dae3a447
--- /dev/null
+++ b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/src/hu/bme/mit/inf/dslreasoner/ilp/cbc/CbcResult.java
@@ -0,0 +1,54 @@
+package hu.bme.mit.inf.dslreasoner.ilp.cbc;
+public abstract class CbcResult {
+        public static final CbcResult SOLUTION_UNBOUNDED = new CbcResult() {
+        };
+        public static final CbcResult UNSAT = new CbcResult() {
+        };
+        
+        public static final CbcResult ABANDONED = new CbcResult() {
+        };
+        public static final CbcResult TIMEOUT = new CbcResult() {
+        };
+        private CbcResult() {
+        }
+        public static class SolutionBounded extends CbcResult {
+                public final double value;
+                public SolutionBounded(double value) {
+                        this.value = value;
+                }
+                public double getValue() {
+                        return value;
+                }
+                @Override
+                public int hashCode() {
+                        final int prime = 31;
+                        int result = 1;
+                        long temp;
+                        temp = Double.doubleToLongBits(value);
+                        result = prime * result + (int) (temp ^ (temp >>> 32));
+                        return result;
+                }
+                @Override
+                public boolean equals(Object obj) {
+                        if (this == obj)
+                                return true;
+                        if (obj == null)
+                                return false;
+                        if (getClass() != obj.getClass())
+                                return false;
+                        SolutionBounded other = (SolutionBounded) obj;
+                        if (Double.doubleToLongBits(value) != Double.doubleToLongBits(other.value))
+                                return false;
+                        return true;
+                }
+        }
+}
diff --git a/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/src/hu/bme/mit/inf/dslreasoner/ilp/cbc/CbcSolver.java b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/src/hu/bme/mit/inf/dslreasoner/ilp/cbc/CbcSolver.java
new file mode 100644
index 00000000..085d4448
--- /dev/null
+++ b/Solvers/ILP-Solver/hu.bme.mit.inf.dslreasoner.ilp.cbc/src/hu/bme/mit/inf/dslreasoner/ilp/cbc/CbcSolver.java
@@ -0,0 +1,71 @@
+package hu.bme.mit.inf.dslreasoner.ilp.cbc;
+public class CbcSolver {
+        private static int CBC_SOLUTION_BOUNDED = 0;
+        private static int CBC_SOLUTION_UNBOUNDED = 1;
+        private static int CBC_UNSAT = 2;
+        private static int CBC_ABANDONED = 3;
+        private static int CBC_TIMEOUT = 4;
+        private static int CBC_ERROR = 5;
+        private static boolean nativesLoaded = false;
+        private CbcSolver() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly.");
+        }
+        public static CbcResult solve(double[] columnLowerBounds, double[] columnUpperBounds, int[] rowStarts,
+                        int[] columnIndices, double[] entries, double[] rowLowerBounds, double[] rowUpperBounds, double[] objective,
+                        boolean lpRelaxation, double timeoutSeconds, boolean silent) {
+                loadNatives();
+                validate(columnLowerBounds, columnUpperBounds, rowStarts, columnIndices, entries, rowLowerBounds,
+                                rowUpperBounds, objective);
+                double[] output = new double[1];
+                int result = solveIlpProblem(columnLowerBounds, columnUpperBounds, rowStarts, columnIndices, entries,
+                                rowLowerBounds, rowUpperBounds, objective, output, lpRelaxation, timeoutSeconds, silent);
+                if (result == CBC_SOLUTION_BOUNDED) {
+                        return new CbcResult.SolutionBounded(output[0]);
+                } else if (result == CBC_SOLUTION_UNBOUNDED) {
+                        return CbcResult.SOLUTION_UNBOUNDED;
+                } else if (result == CBC_UNSAT) {
+                        return CbcResult.UNSAT;
+                } else if (result == CBC_ABANDONED) {
+                        return CbcResult.ABANDONED;
+                } else if (result == CBC_TIMEOUT) {
+                        return CbcResult.TIMEOUT;
+                } else if (result == CBC_ERROR) {
+                        throw new CbcException("Solver signalled error, but no exception was thrown");
+                } else {
+                        throw new CbcException("Unknown return value: " + result);
+                }
+        }
+        private static void loadNatives() {
+                if (!nativesLoaded) {
+                        synchronized (CbcSolver.class) {
+                                System.loadLibrary("viatracbc");
+                                nativesLoaded = true;
+                        }
+                }
+        }
+        private static void validate(double[] columnLowerBounds, double[] columnUpperBounds, int[] rowStarts,
+                        int[] columnIndices, double[] entries, double[] rowLowerBounds, double[] rowUpperBounds,
+                        double[] objective) {
+                int numColumns = columnLowerBounds.length;
+                if (columnUpperBounds.length != numColumns) {
+                        throw new CbcException("Lengths of columnLowerBounds and columnUpperBounds must match");
+                }
+                if (objective.length != numColumns) {
+                        throw new CbcException("Lengths of columnLowerBounds and objective must match");
+                }
+                int numRows = rowLowerBounds.length;
+                if (rowUpperBounds.length != numRows) {
+                        throw new CbcException("Lengths of rowLowerBounds and rowUpperBounds must match");
+                }
+        }
+        private static native int solveIlpProblem(double[] columnLowerBounds, double[] columnUpperBounds, int[] rowStarts,
+                        int[] columnIndices, double[] entries, double[] rowLowerBounds, double[] rowUpperBounds, double[] objective,
+                        double[] output, boolean lpRelaxation, double timeoutSeconds, boolean silent);
+}
diff --git a/Solvers/SMT-Solver/com.microsoft.z3/.classpath b/Solvers/SMT-Solver/com.microsoft.z3/.classpath
new file mode 100644
index 00000000..ffdc022a
--- /dev/null
+++ b/Solvers/SMT-Solver/com.microsoft.z3/.classpath
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+        <classpathentry exported="true" kind="lib" path="com.microsoft.z3.jar">
+                <attributes>
+                        <attribute name="org.eclipse.jdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY" value="com.microsoft.z3/lib"/>
+                </attributes>
+        </classpathentry>
+        <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER">
+                <attributes>
+                        <attribute name="module" value="true"/>
+                </attributes>
+        </classpathentry>
+        <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+        <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/Solvers/SMT-Solver/com.microsoft.z3/.gitignore b/Solvers/SMT-Solver/com.microsoft.z3/.gitignore
new file mode 100644
index 00000000..ae3c1726
--- /dev/null
+++ b/Solvers/SMT-Solver/com.microsoft.z3/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/Solvers/SMT-Solver/com.microsoft.z3/.project b/Solvers/SMT-Solver/com.microsoft.z3/.project
new file mode 100644
index 00000000..ec5bbc58
--- /dev/null
+++ b/Solvers/SMT-Solver/com.microsoft.z3/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+        <name>com.microsoft.z3</name>
+        <comment></comment>
+        <projects>
+        </projects>
+        <buildSpec>
+                <buildCommand>
+                        <name>org.eclipse.jdt.core.javabuilder</name>
+                        <arguments>
+                        </arguments>
+                </buildCommand>
+                <buildCommand>
+                        <name>org.eclipse.pde.ManifestBuilder</name>
+                        <arguments>
+                        </arguments>
+                </buildCommand>
+                <buildCommand>
+                        <name>org.eclipse.pde.SchemaBuilder</name>
+                        <arguments>
+                        </arguments>
+                </buildCommand>
+        </buildSpec>
+        <natures>
+                <nature>org.eclipse.pde.PluginNature</nature>
+                <nature>org.eclipse.jdt.core.javanature</nature>
+        </natures>
+</projectDescription>
diff --git a/Solvers/SMT-Solver/com.microsoft.z3/META-INF/MANIFEST.MF b/Solvers/SMT-Solver/com.microsoft.z3/META-INF/MANIFEST.MF
new file mode 100644
index 00000000..d91e3272
--- /dev/null
+++ b/Solvers/SMT-Solver/com.microsoft.z3/META-INF/MANIFEST.MF
@@ -0,0 +1,22 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Z3
+Bundle-SymbolicName: com.microsoft.z3
+Bundle-Version: 4.8.8.qualifier
+Bundle-Vendor: Microsoft
+Automatic-Module-Name: com.microsoft.z3
+Bundle-ClassPath: com.microsoft.z3.jar
+Bundle-NativeCode: lib/libz3.so;
+ lib/libz3java.so;
+ osname=Linux;
+ processor=x86_64,
+ lib/libz3.dylib;
+ lib/libz3java.dylib;
+ osname=MacOSX;
+ processor=x86_64,
+ lib/libz3.dll;
+ lib/libz3java.dll;
+ osname=win32;
+ processor=x86_64
+Export-Package: com.microsoft.z3,
+ com.microsoft.z3.enumerations
diff --git a/Solvers/SMT-Solver/com.microsoft.z3/build.properties b/Solvers/SMT-Solver/com.microsoft.z3/build.properties
new file mode 100644
index 00000000..87f4e73f
--- /dev/null
+++ b/Solvers/SMT-Solver/com.microsoft.z3/build.properties
@@ -0,0 +1,3 @@
+bin.includes = META-INF/,\
+               lib/,\
+               com.microsoft.z3.jar
diff --git a/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3.dll b/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3.dll
new file mode 100644
index 00000000..46b1e7c2
--- /dev/null
+++ b/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3.dll
Binary files differ
diff --git a/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3.dylib b/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3.dylib
new file mode 100755
index 00000000..6ca9aea8
--- /dev/null
+++ b/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3.dylib
Binary files differ
diff --git a/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3.so b/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3.so
new file mode 100755
index 00000000..0a9853ae
--- /dev/null
+++ b/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3.so
Binary files differ
diff --git a/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3java.dll b/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3java.dll
new file mode 100644
index 00000000..615bf3b8
--- /dev/null
+++ b/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3java.dll
Binary files differ
diff --git a/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3java.dylib b/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3java.dylib
new file mode 100755
index 00000000..73e02b97
--- /dev/null
+++ b/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3java.dylib
Binary files differ
diff --git a/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3java.so b/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3java.so
new file mode 100755
index 00000000..54b05d9a
--- /dev/null
+++ b/Solvers/SMT-Solver/com.microsoft.z3/lib/libz3java.so
Binary files differ
diff --git a/Solvers/SMT-Solver/hu.bme.mit.inf.dslreasoner.smt.language/.launch/Generate Language Infrastructure (hu.bme.mit.inf.dslreasoner.smt.language).launch b/Solvers/SMT-Solver/hu.bme.mit.inf.dslreasoner.smt.language/.launch/Generate Language Infrastructure (hu.bme.mit.inf.dslreasoner.smt.language).launch
deleted file mode 100644
index e448edbe..00000000
--- a/Solvers/SMT-Solver/hu.bme.mit.inf.dslreasoner.smt.language/.launch/Generate Language Infrastructure (hu.bme.mit.inf.dslreasoner.smt.language).launch
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<launchConfiguration type="org.eclipse.emf.mwe2.launch.Mwe2LaunchConfigurationType">
-<stringAttribute key="org.eclipse.debug.core.ATTR_REFRESH_SCOPE" value="${working_set:&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;&#10;&lt;launchConfigurationWorkingSet factoryID=&quot;org.eclipse.ui.internal.WorkingSetFactory&quot; id=&quot;1299248699643_13&quot; label=&quot;working set&quot; name=&quot;working set&quot;&gt;&#10;&lt;item factoryID=&quot;org.eclipse.ui.internal.model.ResourceFactory&quot; path=&quot;/hu.bme.mit.inf.dslreasoner.smt.language&quot; type=&quot;4&quot;/&gt;&#10;&lt;item factoryID=&quot;org.eclipse.ui.internal.model.ResourceFactory&quot; path=&quot;/hu.bme.mit.inf.dslreasoner.smt.language.generator&quot; type=&quot;4&quot;/&gt;&#10;&lt;item factoryID=&quot;org.eclipse.ui.internal.model.ResourceFactory&quot; path=&quot;/hu.bme.mit.inf.dslreasoner.smt.language.tests&quot; type=&quot;4&quot;/&gt;&#10;&lt;item factoryID=&quot;org.eclipse.ui.internal.model.ResourceFactory&quot; path=&quot;/hu.bme.mit.inf.dslreasoner.smt.language.ui&quot; type=&quot;4&quot;/&gt;&#10;&lt;/launchConfigurationWorkingSet&gt;}"/>
-<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
-<listEntry value="/hu.bme.mit.inf.dslreasoner.smt.language"/>
-</listAttribute>
-<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
-<listEntry value="4"/>
-</listAttribute>
-<listAttribute key="org.eclipse.debug.ui.favoriteGroups">
-<listEntry value="org.eclipse.debug.ui.launchGroup.run"/>
-</listAttribute>
-<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher"/>
-<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="src/hu/bme/mit/inf/dslreasoner/GenerateSmtLanguage.mwe2"/>
-<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="hu.bme.mit.inf.dslreasoner.smt.language"/>
-<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Xmx512m"/>
-</launchConfiguration>
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF
index 23e3ad13..f9090901 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF
@@ -4,6 +4,9 @@ Bundle-Name: Logic2viatra
 Bundle-SymbolicName: hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatraquery;singleton:=true
 Bundle-Version: 1.0.0.qualifier
 Export-Package: hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.aggregators,
 hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns,
 hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries
 Require-Bundle: hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0",
@@ -20,7 +23,9 @@ Require-Bundle: hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0",
 com.google.inject;bundle-version="3.0.0",
 org.eclipse.xtext;bundle-version="2.10.0",
 org.eclipse.viatra.transformation.runtime.emf;bundle-version="1.5.0",
- org.eclipse.xtext.xbase;bundle-version="2.10.0"
+ org.eclipse.xtext.xbase;bundle-version="2.10.0",
+ com.microsoft.z3;bundle-version="4.8.5",
+ hu.bme.mit.inf.dslreasoner.ilp.cbc;bundle-version="1.0.0"
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Import-Package: org.apache.log4j
 Automatic-Module-Name: hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatraquery
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/build.properties b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/build.properties
index 585df5ce..9ffc994a 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/build.properties
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/build.properties
@@ -4,6 +4,5 @@ bin.includes = META-INF/,\
 source.. = src/,\
           patterns/,\
           vql-gen/,\
-           xtend-gen/,\
+           xtend-gen/
-           src-gen/
 output.. = bin/
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/Modality.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/Modality.java
index d2132cea..f3a6ec32 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/Modality.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/Modality.java
@@ -2,21 +2,46 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra;
 public enum Modality {
        MUST, MAY, CURRENT;
        public boolean isMust() {
                return this == MUST;
        }
        public boolean isMay() {
                return this == MAY;
        }
        public boolean isCurrent() {
                return this == CURRENT;
        }
        public boolean isMustOrCurrent() {
                return isMust() || isCurrent();
        }
        public Modality getDual() {
-                if(this.isCurrent()) return CURRENT;
+                switch (this) {
-                else if(this.isMust())return MAY;
+                case CURRENT:
-                else return MUST;
+                        return CURRENT;
+                case MUST:
+                        return MAY;
+                case MAY:
+                        return MUST;
+                default:
+                        throw new UnsupportedOperationException("Unknown Modality: " + this);
+                }
+        }
+        public Modality toBase() {
+                if (this.isCurrent()) {
+                        return MUST;
+                } else {
+                        return this;
+                }
+        }
+        @Override
+        public String toString() {
+                return super.toString().toLowerCase();
        }
 }
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend
index b63607f7..6fbbc779 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend
@@ -1,8 +1,20 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra
+import com.google.common.collect.ImmutableMap
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.DocumentationLevel
 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
 import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransfomedViatraQuery
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.CbcPolyhedronSolver
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearTypeConstraintHint
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.MultiplicityGoalConstraintCalculator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronScopePropagator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.RelationConstraintCalculator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagatorStrategy
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.TypeHierarchyScopePropagator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Z3PolyhedronSolver
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.ModalPatternQueries
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PatternProvider
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules.GoalConstraintProvider
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules.RefinementRuleProvider
@@ -10,82 +22,131 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.par
 import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace
 import java.util.Collection
 import java.util.List
+import java.util.Map
 import java.util.Set
 import org.eclipse.viatra.query.runtime.api.IPatternMatch
 import org.eclipse.viatra.query.runtime.api.IQuerySpecification
 import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
 import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule
 import org.eclipse.xtend.lib.annotations.Data
-import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint
-import java.util.Map
 class ModelGenerationStatistics {
        public var long transformationExecutionTime = 0
        synchronized def addExecutionTime(long amount) {
-                transformationExecutionTime+=amount
+                transformationExecutionTime += amount
+        }
+        public var long scopePropagationTime = 0
+        synchronized def addScopePropagationTime(long amount) {
+                scopePropagationTime += amount
+        }
+        public var long preliminaryTypeAnalisisTime = 0
+        public var int decisionsTried = 0
+        synchronized def incrementDecisionCount() {
+                decisionsTried++
+        }
+        public var int transformationInvocations
+        
+        synchronized def incrementTransformationCount() {
+                transformationInvocations++
+        }
+        public var int scopePropagatorInvocations
+        synchronized def incrementScopePropagationCount() {
+                scopePropagatorInvocations++
+        }
+        
+        public var int scopePropagatorSolverInvocations
+        synchronized def incrementScopePropagationSolverCount() {
+                scopePropagatorSolverInvocations++
        }
-        public var long PreliminaryTypeAnalisisTime = 0
 }
 @Data class ModelGenerationMethod {
-         ModelGenerationStatistics statistics
+        ModelGenerationStatistics statistics
-         
-         Collection<? extends BatchTransformationRule<?,?>> objectRefinementRules
+        Collection<? extends BatchTransformationRule<?, ?>> objectRefinementRules
-         Collection<? extends BatchTransformationRule<?,?>> relationRefinementRules
+        Collection<? extends BatchTransformationRule<?, ?>> relationRefinementRules
-         
-         List<MultiplicityGoalConstraintCalculator> unfinishedMultiplicities
+        List<MultiplicityGoalConstraintCalculator> unfinishedMultiplicities
-         Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWF
-         
+        Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWF
-         Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidWF
-         
+        Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidWF
-         Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> mustUnitPropagationPreconditions
-         Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> currentUnitPropagationPreconditions
+        Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> mustUnitPropagationPreconditions
-         
+        Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> currentUnitPropagationPreconditions
-         Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allPatterns
+        Map<String, ModalPatternQueries> modalRelationQueries
+        Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allPatterns
 }
 enum TypeInferenceMethod {
-        Generic, PreliminaryAnalysis
+        Generic,
+        PreliminaryAnalysis
 }
 class ModelGenerationMethodProvider {
-        private val PatternProvider patternProvider = new PatternProvider
+        val PatternProvider patternProvider = new PatternProvider
-        private val RefinementRuleProvider refinementRuleProvider = new RefinementRuleProvider
+        val RefinementRuleProvider refinementRuleProvider = new RefinementRuleProvider
-        private val GoalConstraintProvider goalConstraintProvider = new GoalConstraintProvider
+        val GoalConstraintProvider goalConstraintProvider = new GoalConstraintProvider
-        
+        val relationConstraintCalculator = new RelationConstraintCalculator
-        public def ModelGenerationMethod createModelGenerationMethod(
+        def ModelGenerationMethod createModelGenerationMethod(
                LogicProblem logicProblem,
                PartialInterpretation emptySolution,
                ReasonerWorkspace workspace,
                boolean nameNewElements,
                TypeInferenceMethod typeInferenceMethod,
-                ScopePropagator scopePropagator,
+                ScopePropagatorStrategy scopePropagatorStrategy,
-                DocumentationLevel debugLevel,
+                Collection<LinearTypeConstraintHint> hints,
-                boolean objectCreationCosts
+                DocumentationLevel debugLevel
        ) {
                val statistics = new ModelGenerationStatistics
                val writeFiles = (debugLevel === DocumentationLevel.NORMAL || debugLevel === DocumentationLevel.FULL)
-                
-                val Set<PQuery> existingQueries = logicProblem
+                val Set<PQuery> existingQueries = logicProblem.relations.map[annotations].flatten.filter(TransfomedViatraQuery).
-                        .relations
+                        map[it.patternPQuery as PQuery].toSet
-                        .map[annotations]
-                        .flatten
+                val relationConstraints = relationConstraintCalculator.calculateRelationConstraints(logicProblem)
-                        .filter(TransfomedViatraQuery)
+                val queries = patternProvider.generateQueries(logicProblem, emptySolution, statistics, existingQueries,
-                        .map[it.patternPQuery as PQuery]
+                        workspace, typeInferenceMethod, scopePropagatorStrategy, relationConstraints, hints, writeFiles)
-                        .toSet
+                val scopePropagator = createScopePropagator(scopePropagatorStrategy, emptySolution, hints, queries, statistics)
-                
+                scopePropagator.propagateAllScopeConstraints
-                val queries = patternProvider.generateQueries(logicProblem,emptySolution,statistics,existingQueries,workspace,typeInferenceMethod,writeFiles) 
+                val objectRefinementRules = refinementRuleProvider.createObjectRefinementRules(logicProblem, emptySolution,
-                val //LinkedHashMap<Pair<Relation, ? extends Type>, BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>>
+                        queries, scopePropagator, nameNewElements, statistics)
-                        objectRefinementRules = refinementRuleProvider.createObjectRefinementRules(logicProblem, emptySolution, queries,scopePropagator,nameNewElements,statistics)
+                val relationRefinementRules = refinementRuleProvider.createRelationRefinementRules(queries, scopePropagator,
-                val relationRefinementRules = refinementRuleProvider.createRelationRefinementRules(queries,statistics)
+                        statistics)
-                
-                val unfinishedMultiplicities = goalConstraintProvider.getUnfinishedMultiplicityQueries(logicProblem,queries,objectCreationCosts)
+                val unfinishedMultiplicities = goalConstraintProvider.getUnfinishedMultiplicityQueries(logicProblem,queries)
                val unfinishedWF = queries.getUnfinishedWFQueries.values
-                
+                val modalRelationQueriesBuilder = ImmutableMap.builder
+                for (entry : queries.modalRelationQueries.entrySet) {
+                        val annotation = entry.key.annotations.filter(TransfomedViatraQuery).head
+                        if (annotation !== null) {
+                                modalRelationQueriesBuilder.put(annotation.patternFullyQualifiedName, entry.value)
+                        }
+                }
+                val modalRelationQueries = modalRelationQueriesBuilder.build
                val invalidWF = queries.getInvalidWFQueries.values
                
                val mustUnitPropagationPreconditions = queries.getMustUnitPropagationPreconditionPatterns
                val currentUnitPropagationPreconditions = queries.getCurrentUnitPropagationPreconditionPatterns
-                
                return new ModelGenerationMethod(
                        statistics,
                        objectRefinementRules.values,
@@ -95,7 +156,45 @@ class ModelGenerationMethodProvider {
                        invalidWF,
                        mustUnitPropagationPreconditions,
                        currentUnitPropagationPreconditions,
+                        modalRelationQueries,
                        queries.allQueries
                )
        }
+        private def createScopePropagator(ScopePropagatorStrategy scopePropagatorStrategy,
+                PartialInterpretation emptySolution, Collection<LinearTypeConstraintHint> hints, GeneratedPatterns queries,
+                ModelGenerationStatistics statistics) {
+                if (!hints.empty && !(scopePropagatorStrategy instanceof ScopePropagatorStrategy.Polyhedral)) {
+                        throw new IllegalArgumentException("Only the Polyhedral scope propagator strategy can use hints.")
+                }
+                switch (scopePropagatorStrategy) {
+                        case ScopePropagatorStrategy.None,
+                        case ScopePropagatorStrategy.Basic:
+                                new ScopePropagator(emptySolution, statistics)
+                        case ScopePropagatorStrategy.BasicTypeHierarchy:
+                                new TypeHierarchyScopePropagator(emptySolution, statistics)
+                        ScopePropagatorStrategy.Polyhedral: {
+                                val types = queries.refineObjectQueries.keySet.map[newType].toSet
+                                val allPatternsByName = queries.allQueries.toMap[fullyQualifiedName]
+                                val solver = switch (scopePropagatorStrategy.solver) {
+                                        case Z3Integer:
+                                                new Z3PolyhedronSolver(false, scopePropagatorStrategy.timeoutSeconds)
+                                        case Z3Real:
+                                                new Z3PolyhedronSolver(true, scopePropagatorStrategy.timeoutSeconds)
+                                        case Cbc:
+                                                new CbcPolyhedronSolver(false, scopePropagatorStrategy.timeoutSeconds, true)
+                                        case Clp:
+                                                new CbcPolyhedronSolver(true, scopePropagatorStrategy.timeoutSeconds, true)
+                                        default:
+                                                throw new IllegalArgumentException("Unknown polyhedron solver: " +
+                                                        scopePropagatorStrategy.solver)
+                                }
+                                new PolyhedronScopePropagator(emptySolution, statistics, types, queries.multiplicityConstraintQueries,
+                                        queries.hasElementInContainmentQuery, allPatternsByName, hints, solver,
+                                        scopePropagatorStrategy.requiresUpperBoundIndexing, scopePropagatorStrategy.updateHeuristic)
+                        }
+                        default:
+                                throw new IllegalArgumentException("Unknown scope propagator strategy: " + scopePropagatorStrategy)
+                }
+        }
 }
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ScopePropagator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ScopePropagator.xtend
deleted file mode 100644
index 8012776f..00000000
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ScopePropagator.xtend
+++ /dev/null
@@ -1,166 +0,0 @@
-package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope
-import java.util.HashMap
-import java.util.Map
-import java.util.Set
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation
-import java.util.HashSet
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation
-class ScopePropagator {
-        PartialInterpretation partialInterpretation
-        Map<PartialTypeInterpratation,Scope> type2Scope
-        
-        val Map<Scope, Set<Scope>> superScopes
-        val Map<Scope, Set<Scope>> subScopes
-        
-        public new(PartialInterpretation p) {
-                partialInterpretation = p
-                type2Scope = new HashMap
-                for(scope : p.scopes) {
-                        type2Scope.put(scope.targetTypeInterpretation,scope)
-                }
-                
-                superScopes = new HashMap
-                subScopes = new HashMap
-                for(scope : p.scopes) {
-                        superScopes.put(scope,new HashSet)
-                        subScopes.put(scope,new HashSet)
-                }
-                
-                for(scope : p.scopes) {
-                        val target = scope.targetTypeInterpretation
-                        if(target instanceof PartialComplexTypeInterpretation) {
-                                val supertypeInterpretations = target.supertypeInterpretation
-                                for(supertypeInterpretation : supertypeInterpretations) {
-                                        val supertypeScope = type2Scope.get(supertypeInterpretation)
-                                        superScopes.get(scope).add(supertypeScope)
-                                        subScopes.get(supertypeScope).add(scope)
-                                }
-                        }
-                }
-        }
-        
-        def public propagateAllScopeConstraints() {
-                var boolean hadChanged
-                do{
-                        hadChanged = false
-                        for(superScopeEntry : superScopes.entrySet) {
-                                val sub = superScopeEntry.key
-                                hadChanged = propagateLowerLimitUp(sub,partialInterpretation) || hadChanged
-                                hadChanged = propagateUpperLimitDown(sub,partialInterpretation) || hadChanged
-                                for(sup: superScopeEntry.value) {
-                                        hadChanged = propagateLowerLimitUp(sub,sup) || hadChanged
-                                        hadChanged = propagateUpperLimitDown(sub,sup) || hadChanged
-                                }
-                        }
-                } while(hadChanged)
-//              println('''All constraints are propagated.''')
-        }
-        
-        def public propagateAdditionToType(PartialTypeInterpratation t) {
-                val isPrimitive = t instanceof PartialPrimitiveInterpretation || t === null
-                if(!isPrimitive) {
-        //              println('''Adding to «(t as PartialComplexTypeInterpretation).interpretationOf.name»''')
-                        val targetScope = type2Scope.get(t)
-                        if(targetScope!==null) {
-                                targetScope.removeOne
-                                val sups = superScopes.get(targetScope)
-                                sups.forEach[removeOne]
-                        }
-                        
-                        
-                        if(this.partialInterpretation.minNewElements > 0 ) {
-                                this.partialInterpretation.minNewElements = this.partialInterpretation.minNewElements-1
-                        }
-                        if(this.partialInterpretation.maxNewElements > 0) {
-                                this.partialInterpretation.maxNewElements = this.partialInterpretation.maxNewElements-1
-                        } else if(this.partialInterpretation.maxNewElements === 0) {
-                                this.partialInterpretation.maxNewElements = 0
-                                //throw new IllegalArgumentException('''Inconsistent object creation: lower node limit is 0!''')
-                        }
-                        
-        //              subScopes.get(targetScope).forEach[propagateUpperLimitDown(it,targetScope)]
-        //              for(sup: sups) {
-        //                      subScopes.get(sup).forEach[propagateUpperLimitDown(it,sup)]
-        //              }
-        //              for(scope : type2Scope.values) {
-        //                      propagateUpperLimitDown(scope,partialInterpretation)
-        //              }
-        
-                        propagateAllScopeConstraints
-                        
-        //              println('''Target Scope: «targetScope.minNewElements» - «targetScope.maxNewElements»''')
-        //              println(''' «this.partialInterpretation.minNewElements» - «this.partialInterpretation.maxNewElements»''')
-        //              this.partialInterpretation.scopes.forEach[println(''' «(it.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name»: «it.minNewElements»-«it.maxNewElements»''')]
-        //              println('''All constraints are propagated upon increasing «(t as PartialComplexTypeInterpretation).interpretationOf.name»''')
-                }
-        }
-        
-        private def propagateLowerLimitUp(Scope subScope, Scope superScope) {
-                if(subScope.minNewElements>superScope.minNewElements) {
-//                      println('''
-//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> «(superScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name»
-//                      superScope.minNewElements «superScope.minNewElements» = subScope.minNewElements «subScope.minNewElements»
-//                      ''')
-                        superScope.minNewElements = subScope.minNewElements
-                        return true
-                } else {
-                        return false
-                }
-        }
-        
-        private def propagateUpperLimitDown(Scope subScope, Scope superScope) {
-                if(superScope.maxNewElements>=0 && (superScope.maxNewElements<subScope.maxNewElements || subScope.maxNewElements<0)) {
-//                      println('''
-//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> «(superScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name»
-//                      subScope.maxNewElements «subScope.maxNewElements» = superScope.maxNewElements «superScope.maxNewElements»
-//                      ''')
-                        subScope.maxNewElements = superScope.maxNewElements
-                        return true
-                } else {
-                        return false
-                }
-        }
-        
-        private def propagateLowerLimitUp(Scope subScope, PartialInterpretation p) {
-                if(subScope.minNewElements>p.minNewElements) {
-//                      println('''
-//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> nodes
-//                      p.minNewElements «p.minNewElements» = subScope.minNewElements «subScope.minNewElements»
-//                      ''')
-                        p.minNewElements = subScope.minNewElements
-                        return true
-                } else {
-                        return false
-                }
-        }
-        
-        private def propagateUpperLimitDown(Scope subScope, PartialInterpretation p) {
-                if(p.maxNewElements>=0 && (p.maxNewElements<subScope.maxNewElements || subScope.maxNewElements<0)) {
-//                      println('''
-//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> nodes
-//                      subScope.maxNewElements «subScope.maxNewElements» = p.maxNewElements «p.maxNewElements»
-//                      ''')
-                        subScope.maxNewElements = p.maxNewElements
-                        return true
-                } else {
-                        return false
-                }
-        }
-        private def removeOne(Scope scope) {
-                if(scope.maxNewElements===0) {
-                        scope.maxNewElements=0
-                        //throw new IllegalArgumentException('''Inconsistent object creation: «scope.targetTypeInterpretation»''')
-                } else if(scope.maxNewElements>0) {
-                        scope.maxNewElements= scope.maxNewElements-1
-                }
-                if(scope.minNewElements>0) {
-                        scope.minNewElements= scope.minNewElements-1
-                }
-        }
-}
-                        
-\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/AbstractPolyhedronSaturationOperator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/AbstractPolyhedronSaturationOperator.xtend
new file mode 100644
index 00000000..94f97e94
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/AbstractPolyhedronSaturationOperator.xtend
@@ -0,0 +1,53 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+import com.google.common.collect.ImmutableList
+import org.eclipse.xtend.lib.annotations.Accessors
+abstract class AbstractPolyhedronSaturationOperator implements PolyhedronSaturationOperator {
+        @Accessors val Polyhedron polyhedron
+        new(Polyhedron polyhedron) {
+                if (polyhedron.dimensions.empty) {
+                        throw new IllegalArgumentException("Polyhedron must have at least one dimension.")
+                }
+                this.polyhedron = polyhedron
+        }
+        override saturate() {
+                if (polyhedron.expressionsToSaturate.empty) {
+                        return PolyhedronSaturationResult.SATURATED
+                }
+                for (constraint : polyhedron.constraints) {
+                        if (constraint.zero) {
+                                if (constraint.lowerBound !== null && constraint.lowerBound > 0) {
+                                        return PolyhedronSaturationResult.EMPTY
+                                }
+                                if (constraint.upperBound !== null && constraint.upperBound < 0) {
+                                        return PolyhedronSaturationResult.EMPTY
+                                }
+                        } else {
+                                if (constraint.lowerBound !== null && constraint.upperBound !== null &&
+                                        constraint.upperBound < constraint.lowerBound) {
+                                        return PolyhedronSaturationResult.EMPTY
+                                }
+                        }
+                }
+                doSaturate()
+        }
+        protected def PolyhedronSaturationResult doSaturate()
+        protected def getNonTrivialConstraints() {
+                ImmutableList.copyOf(polyhedron.constraints.filter [ constraint |
+                        (constraint.lowerBound !== null || constraint.upperBound !== null) && !constraint.zero
+                ])
+        }
+        private static def isZero(LinearConstraint constraint) {
+                constraint.coefficients.values.forall[it == 0]
+        }
+        override close() throws Exception {
+                // Nothing to close by default.
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/CbcPolyhedronSolver.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/CbcPolyhedronSolver.xtend
new file mode 100644
index 00000000..708f93dc
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/CbcPolyhedronSolver.xtend
@@ -0,0 +1,241 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.ImmutableMap
+import hu.bme.mit.inf.dslreasoner.ilp.cbc.CbcResult
+import hu.bme.mit.inf.dslreasoner.ilp.cbc.CbcSolver
+import java.util.HashSet
+import java.util.List
+import java.util.Map
+import java.util.Set
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+@FinalFieldsConstructor
+class CbcPolyhedronSolver implements PolyhedronSolver {
+        val boolean lpRelaxation
+        val double timeoutSeconds
+        val boolean silent
+        new() {
+                this(false, -1, true)
+        }
+        override createSaturationOperator(Polyhedron polyhedron) {
+                new CbcSaturationOperator(polyhedron, lpRelaxation, timeoutSeconds, silent)
+        }
+}
+class CbcSaturationOperator extends AbstractPolyhedronSaturationOperator {
+        static val EPSILON = 1e-6
+        val boolean lpRelaxation
+        val double timeoutSeconds
+        val boolean silent
+        val double[] columnLowerBounds
+        val double[] columnUpperBounds
+        val double[] objective
+        val Map<Dimension, Integer> dimensionsToIndicesMap
+        new(Polyhedron polyhedron, boolean lpRelaxation, double timeoutSeconds, boolean silent) {
+                super(polyhedron)
+                this.lpRelaxation = lpRelaxation
+                this.timeoutSeconds = timeoutSeconds
+                this.silent = silent
+                val numDimensions = polyhedron.dimensions.size
+                columnLowerBounds = newDoubleArrayOfSize(numDimensions)
+                columnUpperBounds = newDoubleArrayOfSize(numDimensions)
+                objective = newDoubleArrayOfSize(numDimensions)
+                dimensionsToIndicesMap = ImmutableMap.copyOf(polyhedron.dimensions.indexed.toMap([value], [key]))
+        }
+        override doSaturate() {
+                val numDimensions = polyhedron.dimensions.size
+                for (var int j = 0; j < numDimensions; j++) {
+                        val dimension = polyhedron.dimensions.get(j)
+                        columnLowerBounds.set(j, dimension.lowerBound.toDouble(Double.NEGATIVE_INFINITY))
+                        columnUpperBounds.set(j, dimension.upperBound.toDouble(Double.POSITIVE_INFINITY))
+                }
+                val constraints = nonTrivialConstraints
+                val numConstraints = constraints.size
+                val rowStarts = newIntArrayOfSize(numConstraints + 1)
+                val rowLowerBounds = newDoubleArrayOfSize(numConstraints)
+                val rowUpperBounds = newDoubleArrayOfSize(numConstraints)
+                val numEntries = constraints.map[coefficients.size].reduce[a, b|a + b] ?: 0
+                rowStarts.set(numConstraints, numEntries)
+                val columnIndices = newIntArrayOfSize(numEntries)
+                val entries = newDoubleArrayOfSize(numEntries)
+                val unconstrainedDimensions = new HashSet
+                for (dimension : polyhedron.dimensions) {
+                        if (dimension.lowerBound === null && dimension.upperBound === null) {
+                                unconstrainedDimensions += dimension
+                        }
+                }
+                var int index = 0
+                for (var int i = 0; i < numConstraints; i++) {
+                        rowStarts.set(i, index)
+                        val constraint = constraints.get(i)
+                        rowLowerBounds.set(i, constraint.lowerBound.toDouble(Double.NEGATIVE_INFINITY))
+                        rowUpperBounds.set(i, constraint.upperBound.toDouble(Double.POSITIVE_INFINITY))
+                        if (!dimensionsToIndicesMap.keySet.containsAll(constraint.coefficients.keySet)) {
+                                throw new IllegalArgumentException("Constrains has unknown dimensions")
+                        }
+                        for (var int j = 0; j < numDimensions; j++) {
+                                val dimension = polyhedron.dimensions.get(j)
+                                val coefficient = constraint.coefficients.get(dimension)
+                                if (coefficient !== null && coefficient != 0) {
+                                        unconstrainedDimensions -= dimension
+                                        columnIndices.set(index, j)
+                                        entries.set(index, coefficient)
+                                        index++
+                                }
+                        }
+                }
+                if (index != numEntries) {
+                        throw new AssertionError("Last entry does not equal the number of entries in the constraint matrix")
+                }
+                for (expressionToSaturate : polyhedron.expressionsToSaturate) {
+                        val result = saturate(expressionToSaturate, rowStarts, columnIndices, entries, rowLowerBounds,
+                                rowUpperBounds, unconstrainedDimensions, constraints)
+                        if (result != PolyhedronSaturationResult.SATURATED) {
+                                return result
+                        }
+                }
+                PolyhedronSaturationResult.SATURATED
+        }
+        protected def saturate(LinearBoundedExpression expressionToSaturate, int[] rowStarts, int[] columnIndices,
+                double[] entries, double[] rowLowerBounds, double[] rowUpperBounds, Set<Dimension> unconstrainedDimensions,
+                ImmutableList<LinearConstraint> constraints) {
+                val numDimensions = objective.size
+                for (var int j = 0; j < numDimensions; j++) {
+                        objective.set(j, 0)
+                }
+                switch (expressionToSaturate) {
+                        Dimension: {
+                                // CBC will return nonsensical results or call free() with invalid arguments if
+                                // it is passed a fully unconstrained (-Inf lower and +Int upper bound, no inequalities) variable
+                                // in the objective function.
+                                if (unconstrainedDimensions.contains(expressionToSaturate)) {
+                                        return PolyhedronSaturationResult.SATURATED
+                                }
+                                val j = getIndex(expressionToSaturate)
+                                objective.set(j, 1)
+                        }
+                        LinearConstraint: {
+                                for (pair : expressionToSaturate.coefficients.entrySet) {
+                                        val dimension = pair.key
+                                        // We also have to check for unconstrained dimensions here to avoid crashing.
+                                        if (unconstrainedDimensions.contains(dimension)) {
+                                                expressionToSaturate.lowerBound = null
+                                                expressionToSaturate.upperBound = null
+                                                return PolyhedronSaturationResult.SATURATED
+                                        }
+                                        val j = getIndex(dimension)
+                                        objective.set(j, pair.value)
+                                }
+                        }
+                        default:
+                                throw new IllegalArgumentException("Unknown expression: " + expressionToSaturate)
+                }
+                val minimizationResult = CbcSolver.solve(columnLowerBounds, columnUpperBounds, rowStarts, columnIndices,
+                        entries, rowLowerBounds, rowUpperBounds, objective, lpRelaxation, timeoutSeconds, silent)
+                switch (minimizationResult) {
+                        CbcResult.SolutionBounded: {
+                                val doubleValue = minimizationResult.value
+                                val roundedValue = Math.ceil(doubleValue - EPSILON)
+                                val intValue = roundedValue as int
+                                val oldBound = expressionToSaturate.lowerBound
+                                if (oldBound === null || intValue >= oldBound) {
+                                        expressionToSaturate.lowerBound = intValue
+                                        setBound(expressionToSaturate, constraints, roundedValue, columnLowerBounds, rowLowerBounds)
+                                } else {
+                                        throw new IllegalStateException("Unexpected decrease of lower bound by " + (oldBound - doubleValue))
+                                }
+                        }
+                        case CbcResult.SOLUTION_UNBOUNDED: {
+                                if (expressionToSaturate.lowerBound !== null) {
+                                        throw new IllegalStateException("Finite lower bound became infinite")
+                                }
+                                setBound(expressionToSaturate, constraints, Double.NEGATIVE_INFINITY, columnLowerBounds, rowLowerBounds)
+                        }
+                        case CbcResult.UNSAT:
+                                return PolyhedronSaturationResult.EMPTY
+                        case CbcResult.ABANDONED,
+                        case CbcResult.TIMEOUT:
+                                return PolyhedronSaturationResult.UNKNOWN
+                        default:
+                                throw new RuntimeException("Unknown CbcResult: " + minimizationResult)
+                }
+                for (var int j = 0; j < numDimensions; j++) {
+                        val objectiveCoefficient = objective.get(j)
+                        objective.set(j, -objectiveCoefficient)
+                }
+                val maximizationResult = CbcSolver.solve(columnLowerBounds, columnUpperBounds, rowStarts, columnIndices,
+                        entries, rowLowerBounds, rowUpperBounds, objective, lpRelaxation, timeoutSeconds, silent)
+                switch (maximizationResult) {
+                        CbcResult.SolutionBounded: {
+                                val doubleValue = -maximizationResult.value
+                                val roundedValue = Math.floor(doubleValue + EPSILON)
+                                val intValue = roundedValue as int
+                                val oldBound = expressionToSaturate.upperBound
+                                if (oldBound === null || intValue <= oldBound) {
+                                        expressionToSaturate.upperBound = intValue
+                                        setBound(expressionToSaturate, constraints, roundedValue, columnUpperBounds, rowUpperBounds)
+                                } else {
+                                        throw new IllegalStateException("Unexpected increase of upper bound by " + (doubleValue - oldBound))
+                                }
+                        }
+                        case CbcResult.SOLUTION_UNBOUNDED: {
+                                if (expressionToSaturate.lowerBound !== null) {
+                                        throw new IllegalStateException("Finite upper bound became infinite")
+                                }
+                                expressionToSaturate.upperBound = null
+                                setBound(expressionToSaturate, constraints, Double.POSITIVE_INFINITY, columnUpperBounds, rowUpperBounds)
+                        }
+                        case CbcResult.UNSAT:
+                                if (lpRelaxation) {
+                                        return PolyhedronSaturationResult.EMPTY
+                                } else {
+                                        throw new RuntimeException("Minimization was SAT, but maximization is UNSAT")
+                                }
+                        case CbcResult.ABANDONED,
+                        case CbcResult.TIMEOUT:
+                                return PolyhedronSaturationResult.UNKNOWN
+                        default:
+                                throw new RuntimeException("Unknown CbcResult: " + maximizationResult)
+                }
+                return PolyhedronSaturationResult.SATURATED
+        }
+        private def toDouble(Integer nullableInt, double defaultValue) {
+                if (nullableInt === null) {
+                        defaultValue
+                } else {
+                        nullableInt.doubleValue
+                }
+        }
+        private def int getIndex(Dimension dimension) {
+                val index = dimensionsToIndicesMap.get(dimension)
+                if (index === null) {
+                        throw new IllegalArgumentException("Unknown dimension: " + dimension)
+                }
+                index
+        }
+        private def void setBound(LinearBoundedExpression expression, List<LinearConstraint> constraints, double bound,
+                double[] columnBounds, double[] rowBounds) {
+                switch (expression) {
+                        Dimension: {
+                                val j = getIndex(expression)
+                                columnBounds.set(j, bound)
+                        }
+                        LinearConstraint: {
+                                val i = constraints.indexOf(expression)
+                                if (i >= 0) {
+                                        rowBounds.set(i, bound)
+                                }
+                        }
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/LinearTypeConstraintHint.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/LinearTypeConstraintHint.xtend
new file mode 100644
index 00000000..8c21ca1d
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/LinearTypeConstraintHint.xtend
@@ -0,0 +1,30 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PatternGenerator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+interface LinearTypeExpressionBuilderFactory {
+        def ViatraQueryMatcher<? extends IPatternMatch> createMatcher(String queryName)
+        
+        def LinearTypeExpressionBuilder createBuilder()
+}
+interface LinearTypeExpressionBuilder {
+        def LinearTypeExpressionBuilder add(int scale, Type type)
+        def LinearBoundedExpression build()
+}
+@FunctionalInterface
+interface RelationConstraintUpdater {
+        def void update(PartialInterpretation p)
+}
+interface LinearTypeConstraintHint {
+        def CharSequence getAdditionalPatterns(PatternGenerator patternGenerator)
+        
+        def RelationConstraintUpdater createConstraintUpdater(LinearTypeExpressionBuilderFactory builderFactory)
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/MultiplicityGoalConstraintCalculator.xtend
index 05ce4f6e..034420d6 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/MultiplicityGoalConstraintCalculator.xtend
@@ -1,4 +1,4 @@
-package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
 import org.eclipse.emf.common.notify.Notifier
 import org.eclipse.viatra.query.runtime.api.IQuerySpecification
@@ -7,9 +7,9 @@ import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
 import org.eclipse.viatra.query.runtime.emf.EMFScope
 class MultiplicityGoalConstraintCalculator {
-        val String targetRelationName;
+        val String targetRelationName
-        val IQuerySpecification<?> querySpecification;
+        val IQuerySpecification<?> querySpecification
-        var ViatraQueryMatcher<?> matcher;
+        var ViatraQueryMatcher<?> matcher
        val int minValue
        val boolean containment
        val int cost
@@ -23,7 +23,7 @@ class MultiplicityGoalConstraintCalculator {
                this.cost = cost
        }
        
-        public new(MultiplicityGoalConstraintCalculator other) {
+        new(MultiplicityGoalConstraintCalculator other) {
                this.targetRelationName = other.targetRelationName
                this.querySpecification = other.querySpecification
                this.matcher = null
@@ -32,24 +32,23 @@ class MultiplicityGoalConstraintCalculator {
                this.cost = other.cost
        }
        
-        def public getName() {
+        def getName() {
                targetRelationName
        }
        
        def isContainment() {
                return containment
        }
-        
-        def public init(Notifier notifier) {
+        def init(Notifier notifier) {
                val engine = ViatraQueryEngine.on(new EMFScope(notifier))
                matcher = querySpecification.getMatcher(engine)
        }
        
-        def public calculateValue() {
+        def calculateValue() {
                var res = 0
                val allMatches = this.matcher.allMatches
                for(match : allMatches) {
-                        
                        val existingMultiplicity = match.get(4) as Integer
                        if(existingMultiplicity < this.minValue) {
                                val missingMultiplicity = this.minValue-existingMultiplicity
@@ -63,4 +62,4 @@ class MultiplicityGoalConstraintCalculator {
 //              println(targetRelationName+ " all missing multiplicities: "+res + "*"+cost+"="+res*cost)
                return res*cost
        }
-}
-\ No newline at end of file
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronScopePropagator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronScopePropagator.xtend
new file mode 100644
index 00000000..120fb18a
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronScopePropagator.xtend
@@ -0,0 +1,569 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+import com.google.common.cache.Cache
+import com.google.common.cache.CacheBuilder
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.ImmutableMap
+import com.google.common.collect.ImmutableSet
+import com.google.common.collect.Maps
+import com.google.common.collect.Sets
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.UnifinishedMultiplicityQueries
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope
+import java.util.ArrayDeque
+import java.util.ArrayList
+import java.util.Collection
+import java.util.HashMap
+import java.util.HashSet
+import java.util.List
+import java.util.Map
+import java.util.Set
+import javax.naming.OperationNotSupportedException
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.viatra.query.runtime.emf.EMFScope
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+class PolyhedronScopePropagator extends TypeHierarchyScopePropagator {
+        static val CACHE_SIZE = 10000
+        
+        val boolean updateHeuristic
+        val Map<Scope, LinearBoundedExpression> scopeBounds
+        val LinearBoundedExpression topLevelBounds
+        val Polyhedron polyhedron
+        val PolyhedronSaturationOperator operator
+        val Set<Relation> relevantRelations
+        val Cache<PolyhedronSignature, PolyhedronSignature> cache = CacheBuilder.newBuilder.maximumSize(CACHE_SIZE).build
+        List<RelationConstraintUpdater> updaters = emptyList
+        new(PartialInterpretation p, ModelGenerationStatistics statistics, Set<? extends Type> possibleNewDynamicTypes,
+                Map<RelationMultiplicityConstraint, UnifinishedMultiplicityQueries> unfinishedMultiplicityQueries,
+                IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hasElementInContainmentQuery,
+                Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allPatternsByName,
+                Collection<LinearTypeConstraintHint> hints, PolyhedronSolver solver, boolean propagateRelations,
+                boolean updateHeuristic) {
+                super(p, statistics)
+                this.updateHeuristic = updateHeuristic
+                val builder = new PolyhedronBuilder(p)
+                builder.buildPolyhedron(possibleNewDynamicTypes)
+                scopeBounds = builder.scopeBounds
+                topLevelBounds = builder.topLevelBounds
+                polyhedron = builder.polyhedron
+                operator = solver.createSaturationOperator(polyhedron)
+                propagateAllScopeConstraints()
+                if (propagateRelations) {
+                        val maximumNumberOfNewNodes = topLevelBounds.upperBound
+                        if (maximumNumberOfNewNodes === null) {
+                                throw new IllegalStateException("Could not determine maximum number of new nodes, it may be unbounded")
+                        }
+                        if (maximumNumberOfNewNodes <= 0) {
+                                throw new IllegalStateException("Maximum number of new nodes is not positive")
+                        }
+                        builder.buildMultiplicityConstraints(unfinishedMultiplicityQueries, hasElementInContainmentQuery,
+                                allPatternsByName, hints, maximumNumberOfNewNodes)
+                        relevantRelations = builder.relevantRelations
+                        updaters = builder.updaters
+                } else {
+                        relevantRelations = emptySet
+                }
+        }
+        override void doPropagateAllScopeConstraints() {
+                super.doPropagateAllScopeConstraints()
+                resetBounds()
+                populatePolyhedronFromScope()
+//              println(polyhedron)
+                val signature = polyhedron.createSignature
+                val cachedSignature = cache.getIfPresent(signature)
+                switch (cachedSignature) {
+                        case null: {
+                                statistics.incrementScopePropagationSolverCount
+                                val result = operator.saturate()
+                                if (result == PolyhedronSaturationResult.EMPTY) {
+                                        cache.put(signature, PolyhedronSignature.EMPTY)
+                                        setScopesInvalid()
+                                } else {
+                                        val resultSignature = polyhedron.createSignature
+                                        cache.put(signature, resultSignature)
+                                        populateScopesFromPolyhedron()
+                                }
+                        }
+                        case PolyhedronSignature.EMPTY:
+                                setScopesInvalid()
+                        PolyhedronSignature.Bounds: {
+                                polyhedron.applySignature(signature)
+                                populateScopesFromPolyhedron()
+                        }
+                        default:
+                                throw new IllegalStateException("Unknown polyhedron signature: " + signature)
+                }
+//              println(polyhedron)
+                if (updateHeuristic) {
+                        copyScopeBoundsToHeuristic()
+                }
+        }
+        override propagateAdditionToRelation(Relation r) {
+                super.propagateAdditionToRelation(r)
+                if (relevantRelations.contains(r)) {
+                        propagateAllScopeConstraints()
+                }
+        }
+        def resetBounds() {
+                for (dimension : polyhedron.dimensions) {
+                        dimension.lowerBound = 0
+                        dimension.upperBound = null
+                }
+                for (constraint : polyhedron.constraints) {
+                        constraint.lowerBound = null
+                        constraint.upperBound = null
+                }
+        }
+        private def populatePolyhedronFromScope() {
+                topLevelBounds.tightenLowerBound(partialInterpretation.minNewElements)
+                if (partialInterpretation.maxNewElements >= 0) {
+                        topLevelBounds.tightenUpperBound(partialInterpretation.maxNewElements)
+                }
+                for (pair : scopeBounds.entrySet) {
+                        val scope = pair.key
+                        val bounds = pair.value
+                        bounds.tightenLowerBound(scope.minNewElements)
+                        if (scope.maxNewElements >= 0) {
+                                bounds.tightenUpperBound(scope.maxNewElements)
+                        }
+                }
+                for (updater : updaters) {
+                        updater.update(partialInterpretation)
+                }
+        }
+        private def populateScopesFromPolyhedron() {
+                checkBounds(topLevelBounds)
+                if (partialInterpretation.minNewElements > topLevelBounds.lowerBound) {
+                        throw new IllegalArgumentException('''Lower bound of «topLevelBounds» smaller than top-level scope: «partialInterpretation.minNewElements»''')
+                } else if (partialInterpretation.minNewElements != topLevelBounds.lowerBound) {
+                        partialInterpretation.minNewElements = topLevelBounds.lowerBound
+                }
+                val topLevelUpperBound = topLevelBounds.upperBound ?: -1
+                if (partialInterpretation.maxNewElements >= 0 && topLevelUpperBound >= 0 &&
+                        partialInterpretation.maxNewElements < topLevelUpperBound) {
+                        throw new IllegalArgumentException('''Upper bound of «topLevelBounds» larger than top-level scope: «partialInterpretation.maxNewElements»''')
+                } else if (partialInterpretation.maxNewElements != topLevelUpperBound) {
+                        partialInterpretation.maxNewElements = topLevelUpperBound
+                }
+                for (pair : scopeBounds.entrySet) {
+                        val scope = pair.key
+                        val bounds = pair.value
+                        checkBounds(bounds)
+                        if (scope.minNewElements > bounds.lowerBound) {
+                                throw new IllegalArgumentException('''Lower bound of «bounds» smaller than «scope.targetTypeInterpretation» scope: «scope.minNewElements»''')
+                        } else if (scope.minNewElements != bounds.lowerBound) {
+                                scope.minNewElements = bounds.lowerBound
+                        }
+                        val upperBound = bounds.upperBound ?: -1
+                        if (scope.maxNewElements >= 0 && upperBound >= 0 && scope.maxNewElements < upperBound) {
+                                throw new IllegalArgumentException('''Upper bound of «bounds» larger than «scope.targetTypeInterpretation» scope: «scope.maxNewElements»''')
+                        } else if (scope.maxNewElements != upperBound) {
+                                scope.maxNewElements = upperBound
+                        }
+                }
+        }
+        private def checkBounds(LinearBoundedExpression bounds) {
+                if (bounds.lowerBound === null) {
+                        throw new IllegalArgumentException("Infinite lower bound: " + bounds)
+                } else if (bounds.lowerBound < 0) {
+                        throw new IllegalArgumentException("Negative lower bound: " + bounds)
+                }
+                if (bounds.upperBound !== null && bounds.upperBound < 0) {
+                        throw new IllegalArgumentException("Negative upper bound: " + bounds)
+                }
+        } 
+        private static def <T extends IPatternMatch> getCalculatedMultiplicity(ViatraQueryMatcher<T> matcher,
+                PartialInterpretation p) {
+                val match = matcher.newEmptyMatch
+                match.set(0, p.problem)
+                match.set(1, p)
+                val iterator = matcher.streamAllMatches(match).iterator
+                if (!iterator.hasNext) {
+                        return null
+                }
+                val value = iterator.next.get(2) as Integer
+                if (iterator.hasNext) {
+                        throw new IllegalArgumentException("Multiplicity calculation query has more than one match")
+                }
+                value
+        }
+        @FinalFieldsConstructor
+        private static class PolyhedronBuilder implements LinearTypeExpressionBuilderFactory {
+                static val INFINITY_SCALE = 10
+                val PartialInterpretation p
+                Map<Type, Dimension> instanceCounts
+                Map<Type, Map<Dimension, Integer>> subtypeDimensions
+                Map<Map<Dimension, Integer>, LinearBoundedExpression> expressionsCache
+                Map<Type, LinearBoundedExpression> typeBounds
+                int infinity
+                ViatraQueryEngine queryEngine
+                Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allPatternsByName
+                ImmutableList.Builder<RelationConstraintUpdater> updatersBuilder
+                Map<Scope, LinearBoundedExpression> scopeBounds
+                LinearBoundedExpression topLevelBounds
+                Polyhedron polyhedron
+                Set<Relation> relevantRelations
+                List<RelationConstraintUpdater> updaters
+                def buildPolyhedron(Set<? extends Type> possibleNewDynamicTypes) {
+                        instanceCounts = possibleNewDynamicTypes.toInvertedMap[new Dimension(name, 0, null)]
+                        val types = p.problem.types
+                        expressionsCache = Maps.newHashMapWithExpectedSize(types.size)
+                        subtypeDimensions = types.toInvertedMap[findSubtypeDimensions.toInvertedMap[1]]
+                        typeBounds = ImmutableMap.copyOf(subtypeDimensions.mapValues[toExpression])
+                        scopeBounds = buildScopeBounds
+                        topLevelBounds = instanceCounts.values.toInvertedMap[1].toExpression
+                        val dimensions = ImmutableList.copyOf(instanceCounts.values)
+                        val expressionsToSaturate = ImmutableList.copyOf(scopeBounds.values)
+                        polyhedron = new Polyhedron(dimensions, new ArrayList, expressionsToSaturate)
+                        addCachedConstraintsToPolyhedron()
+                }
+                def buildMultiplicityConstraints(
+                        Map<RelationMultiplicityConstraint, UnifinishedMultiplicityQueries> constraints,
+                        IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hasElementInContainmentQuery,
+                        Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allPatternsByName,
+                        Collection<LinearTypeConstraintHint> hints, int maximumNuberOfNewNodes) {
+                        infinity = maximumNuberOfNewNodes * INFINITY_SCALE
+                        queryEngine = ViatraQueryEngine.on(new EMFScope(p))
+                        this.allPatternsByName = allPatternsByName
+                        updatersBuilder = ImmutableList.builder
+                        val containmentConstraints = constraints.entrySet.filter[key.containment].groupBy[key.targetType]
+                        for (pair : containmentConstraints.entrySet) {
+                                buildContainmentConstraints(pair.key, pair.value)
+                        }
+                        buildConstainmentRootConstraints(containmentConstraints.keySet, hasElementInContainmentQuery)
+                        for (pair : constraints.entrySet) {
+                                val constraint = pair.key
+                                if (!constraint.containment) {
+                                        buildNonContainmentConstraints(constraint, pair.value)
+                                }
+                        }
+                        buildRelevantRelations(constraints.keySet)
+                        for (hint : hints) {
+                                updatersBuilder.add(hint.createConstraintUpdater(this))
+                        }
+                        updaters = updatersBuilder.build
+                        addCachedConstraintsToPolyhedron()
+                }
+                private def buildRelevantRelations(Set<RelationMultiplicityConstraint> constraints) {
+                        val builder = ImmutableSet.builder
+                        for (constraint : constraints) {
+                                builder.add(constraint.relation)
+                                if (constraint.inverseRelation !== null) {
+                                        builder.add(constraint.inverseRelation)
+                                }
+                        }
+                        relevantRelations = builder.build
+                }
+                private def addCachedConstraintsToPolyhedron() {
+                        val constraints = new HashSet
+                        constraints.addAll(expressionsCache.values.filter(LinearConstraint))
+                        constraints.removeAll(polyhedron.constraints)
+                        polyhedron.constraints.addAll(constraints)
+                }
+                private def buildContainmentConstraints(Type containedType,
+                        List<Map.Entry<RelationMultiplicityConstraint, UnifinishedMultiplicityQueries>> constraints) {
+                        val typeCoefficients = subtypeDimensions.get(containedType)
+                        val orphansLowerBoundCoefficients = new HashMap(typeCoefficients)
+                        val orphansUpperBoundCoefficients = new HashMap(typeCoefficients)
+                        val unfinishedMultiplicitiesMatchersBuilder = ImmutableList.builder
+                        val remainingContentsQueriesBuilder = ImmutableList.builder
+                        for (pair : constraints) {
+                                val constraint = pair.key
+                                val containerCoefficients = subtypeDimensions.get(constraint.sourceType)
+                                if (constraint.isUpperBoundFinite) {
+                                        orphansLowerBoundCoefficients.addCoefficients(-constraint.upperBound, containerCoefficients)
+                                } else {
+                                        orphansLowerBoundCoefficients.addCoefficients(-infinity, containerCoefficients)
+                                }
+                                orphansUpperBoundCoefficients.addCoefficients(-constraint.lowerBound, containerCoefficients)
+                                val queries = pair.value
+                                if (constraint.constrainsUnfinished) {
+                                        if (queries.unfinishedMultiplicityQuery === null) {
+                                                throw new IllegalArgumentException(
+                                                        "Containment constraints need unfinished multiplicity queries")
+                                        }
+                                        unfinishedMultiplicitiesMatchersBuilder.add(
+                                                queries.unfinishedMultiplicityQuery.getMatcher(queryEngine))
+                                }
+                                if (queries.remainingContentsQuery === null) {
+                                        throw new IllegalArgumentException("Containment constraints need remaining contents queries")
+                                }
+                                remainingContentsQueriesBuilder.add(queries.remainingContentsQuery.getMatcher(queryEngine))
+                        }
+                        val orphanLowerBound = orphansLowerBoundCoefficients.toExpression
+                        val orphanUpperBound = orphansUpperBoundCoefficients.toExpression
+                        val updater = new ContainmentConstraintUpdater(containedType.name, orphanLowerBound, orphanUpperBound,
+                                unfinishedMultiplicitiesMatchersBuilder.build, remainingContentsQueriesBuilder.build)
+                        updatersBuilder.add(updater)
+                }
+                private def buildConstainmentRootConstraints(Set<Type> containedTypes,
+                        IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hasElementInContainmentQuery) {
+                        val matcher = hasElementInContainmentQuery.getMatcher(queryEngine)
+                        val rootDimensions = Sets.newHashSet(instanceCounts.values)
+                        for (type : containedTypes) {
+                                val containedDimensions = subtypeDimensions.get(type).keySet
+                                rootDimensions.removeAll(containedDimensions)
+                        }
+                        for (dimension : rootDimensions) {
+                                updatersBuilder.add(new ContainmentRootConstraintUpdater(dimension, matcher))
+                        }
+                }
+                private def buildNonContainmentConstraints(RelationMultiplicityConstraint constraint,
+                        UnifinishedMultiplicityQueries queries) {
+                        if (constraint.constrainsRemainingInverse) {
+                                if (queries.unfinishedMultiplicityQuery === null) {
+                                        throw new IllegalArgumentException("Reference constraints need unfinished multiplicity queries")
+                                }
+                                val unfinishedMultiplicityMatcher = queries.unfinishedMultiplicityQuery.getMatcher(queryEngine)
+                                if (queries.remainingInverseMultiplicityQuery === null) {
+                                        throw new IllegalArgumentException(
+                                                "Reference constraints need remaining inverse multiplicity queries")
+                                }
+                                val remainingInverseMultiplicityMatcher = queries.remainingInverseMultiplicityQuery.getMatcher(
+                                        queryEngine)
+                                val availableMultiplicityCoefficients = new HashMap
+                                availableMultiplicityCoefficients.addCoefficients(constraint.inverseUpperBound,
+                                        subtypeDimensions.get(constraint.targetType))
+                                availableMultiplicityCoefficients.addCoefficients(-constraint.lowerBound,
+                                        subtypeDimensions.get(constraint.targetType))
+                                val availableMultiplicity = availableMultiplicityCoefficients.toExpression
+                                updatersBuilder.add(
+                                        new UnfinishedMultiplicityConstraintUpdater(constraint.relation.name, availableMultiplicity,
+                                                unfinishedMultiplicityMatcher, remainingInverseMultiplicityMatcher))
+                        }
+                        if (constraint.constrainsUnrepairable) {
+                                if (queries.unrepairableMultiplicityQuery === null) {
+                                        throw new IllegalArgumentException("Reference constraints need unrepairable multiplicity queries")
+                                }
+                                val unrepairableMultiplicityMatcher = queries.unrepairableMultiplicityQuery.getMatcher(queryEngine)
+                                val targetTypeCardinality = typeBounds.get(constraint.targetType)
+                                updatersBuilder.add(
+                                        new UnrepairableMultiplicityConstraintUpdater(constraint.relation.name, targetTypeCardinality,
+                                                unrepairableMultiplicityMatcher))
+                        }
+                }
+                private static def addCoefficients(Map<Dimension, Integer> accumulator, int scale, Map<Dimension, Integer> a) {
+                        for (pair : a.entrySet) {
+                                val dimension = pair.key
+                                val currentValue = accumulator.get(pair.key) ?: 0
+                                val newValue = currentValue + scale * pair.value
+                                if (newValue == 0) {
+                                        accumulator.remove(dimension)
+                                } else {
+                                        accumulator.put(dimension, newValue)
+                                }
+                        }
+                }
+                private def findSubtypeDimensions(Type type) {
+                        val subtypes = new HashSet
+                        val dimensions = new HashSet
+                        val stack = new ArrayDeque
+                        stack.addLast(type)
+                        while (!stack.empty) {
+                                val subtype = stack.removeLast
+                                if (subtypes.add(subtype)) {
+                                        val dimension = instanceCounts.get(subtype)
+                                        if (dimension !== null) {
+                                                dimensions.add(dimension)
+                                        }
+                                        stack.addAll(subtype.subtypes)
+                                }
+                        }
+                        dimensions
+                }
+                private def toExpression(Map<Dimension, Integer> coefficients) {
+                        expressionsCache.computeIfAbsent(coefficients) [ c |
+                                if (c.size == 1 && c.entrySet.head.value == 1) {
+                                        c.entrySet.head.key
+                                } else {
+                                        new LinearConstraint(c, null, null)
+                                }
+                        ]
+                }
+                private def buildScopeBounds() {
+                        val scopeBoundsBuilder = ImmutableMap.builder
+                        for (scope : p.scopes) {
+                                switch (targetTypeInterpretation : scope.targetTypeInterpretation) {
+                                        PartialPrimitiveInterpretation:
+                                                throw new OperationNotSupportedException("Primitive type scopes are not yet implemented")
+                                        PartialComplexTypeInterpretation: {
+                                                val complexType = targetTypeInterpretation.interpretationOf
+                                                val typeBound = typeBounds.get(complexType)
+                                                if (typeBound === null) {
+                                                        if (scope.minNewElements > 0) {
+                                                                throw new IllegalArgumentException("Found scope for " + complexType.name +
+                                                                        ", but the type cannot be instantiated")
+                                                        }
+                                                } else {
+                                                        scopeBoundsBuilder.put(scope, typeBound)
+                                                }
+                                        }
+                                        default:
+                                                throw new IllegalArgumentException("Unknown PartialTypeInterpretation: " +
+                                                        targetTypeInterpretation)
+                                }
+                        }
+                        scopeBoundsBuilder.build
+                }
+                override createMatcher(String queryName) {
+                        val querySpecification = allPatternsByName.get(queryName)
+                        if (querySpecification === null) {
+                                throw new IllegalArgumentException("Unknown pattern: " + queryName)
+                        }
+                        querySpecification.getMatcher(queryEngine)
+                }
+                override createBuilder() {
+                        new PolyhedronBuilderLinearTypeExpressionBuilder(this)
+                }
+        }
+        @FinalFieldsConstructor
+        private static class PolyhedronBuilderLinearTypeExpressionBuilder implements LinearTypeExpressionBuilder {
+                val PolyhedronBuilder polyhedronBuilder
+                val Map<Dimension, Integer> coefficients = new HashMap
+                override add(int scale, Type type) {
+                        val typeCoefficients = polyhedronBuilder.subtypeDimensions.get(type)
+                        if (typeCoefficients === null) {
+                                throw new IllegalArgumentException("Unknown type: " + type)
+                        }
+                        PolyhedronBuilder.addCoefficients(coefficients, scale, typeCoefficients)
+                        this
+                }
+                override build() {
+                        polyhedronBuilder.toExpression(coefficients)
+                }
+        }
+        @FinalFieldsConstructor
+        private static class ContainmentConstraintUpdater implements RelationConstraintUpdater {
+                val String name
+                val LinearBoundedExpression orphansLowerBound
+                val LinearBoundedExpression orphansUpperBound
+                val List<ViatraQueryMatcher<? extends IPatternMatch>> unfinishedMultiplicitiesMatchers
+                val List<ViatraQueryMatcher<? extends IPatternMatch>> remainingContentsQueries
+                override update(PartialInterpretation p) {
+                        tightenLowerBound(p)
+                        tightenUpperBound(p)
+                }
+                private def tightenLowerBound(PartialInterpretation p) {
+                        var int sum = 0
+                        for (matcher : remainingContentsQueries) {
+                                val value = matcher.getCalculatedMultiplicity(p)
+                                if (value === null) {
+                                        throw new IllegalArgumentException("Remaining contents count is missing for " + name)
+                                }
+                                if (value == -1) {
+                                        // Infinite upper bound, no need to tighten.
+                                        return
+                                }
+                                sum += value
+                        }
+                        orphansLowerBound.tightenUpperBound(sum)
+                }
+                private def tightenUpperBound(PartialInterpretation p) {
+                        var int sum = 0
+                        for (matcher : unfinishedMultiplicitiesMatchers) {
+                                val value = matcher.getCalculatedMultiplicity(p)
+                                if (value === null) {
+                                        throw new IllegalArgumentException("Unfinished multiplicity is missing for " + name)
+                                }
+                                sum += value
+                        }
+                        orphansUpperBound.tightenLowerBound(sum)
+                }
+        }
+        @FinalFieldsConstructor
+        private static class ContainmentRootConstraintUpdater implements RelationConstraintUpdater {
+                val LinearBoundedExpression typeCardinality
+                val ViatraQueryMatcher<? extends IPatternMatch> hasElementInContainmentMatcher
+                override update(PartialInterpretation p) {
+                        if (hasElementInContainmentMatcher.hasMatch(p)) {
+                                typeCardinality.tightenUpperBound(0)
+                        } else {
+                                typeCardinality.tightenUpperBound(1)
+                        }
+                }
+                private static def <T extends IPatternMatch> hasMatch(ViatraQueryMatcher<T> matcher, PartialInterpretation p) {
+                        val match = matcher.newMatch(p.problem, p)
+                        matcher.countMatches(match) != 0
+                }
+        }
+        @FinalFieldsConstructor
+        private static class UnfinishedMultiplicityConstraintUpdater implements RelationConstraintUpdater {
+                val String name
+                val LinearBoundedExpression availableMultiplicityExpression
+                val ViatraQueryMatcher<? extends IPatternMatch> unfinishedMultiplicityMatcher
+                val ViatraQueryMatcher<? extends IPatternMatch> remainingInverseMultiplicityMatcher
+                override update(PartialInterpretation p) {
+                        val unfinishedMultiplicity = unfinishedMultiplicityMatcher.getCalculatedMultiplicity(p)
+                        if (unfinishedMultiplicity === null) {
+                                throw new IllegalArgumentException("Unfinished multiplicity is missing for " + name)
+                        }
+                        val remainingInverseMultiplicity = remainingInverseMultiplicityMatcher.getCalculatedMultiplicity(p)
+                        if (remainingInverseMultiplicity === null) {
+                                throw new IllegalArgumentException("Remaining inverse multiplicity is missing for " + name)
+                        }
+                        val int requiredMultiplicity = unfinishedMultiplicity - remainingInverseMultiplicity
+                        availableMultiplicityExpression.tightenLowerBound(requiredMultiplicity)
+                }
+        }
+        @FinalFieldsConstructor
+        private static class UnrepairableMultiplicityConstraintUpdater implements RelationConstraintUpdater {
+                val String name
+                val LinearBoundedExpression targetCardinalityExpression
+                val ViatraQueryMatcher<? extends IPatternMatch> unrepairableMultiplicityMatcher
+                override update(PartialInterpretation p) {
+                        val value = unrepairableMultiplicityMatcher.getCalculatedMultiplicity(p)
+                        if (value === null) {
+                                throw new IllegalArgumentException("Unrepairable multiplicity is missing for " + name)
+                        }
+                        targetCardinalityExpression.tightenLowerBound(value)
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronSolver.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronSolver.xtend
new file mode 100644
index 00000000..4e046190
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronSolver.xtend
@@ -0,0 +1,179 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+import java.util.List
+import java.util.Map
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.Data
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+interface PolyhedronSolver {
+        def PolyhedronSaturationOperator createSaturationOperator(Polyhedron polyhedron)
+}
+enum PolyhedronSaturationResult {
+        SATURATED,
+        EMPTY,
+        UNKNOWN
+}
+interface PolyhedronSaturationOperator extends AutoCloseable {
+        def Polyhedron getPolyhedron()
+        def PolyhedronSaturationResult saturate()
+}
+@FinalFieldsConstructor
+@Accessors
+class Polyhedron {
+        /**
+         * The list of dimensions (variables) for this polyhedron.
+         * 
+         * This list must not be modified after the polyhedron was created.
+         * However, lower and upper bounds of the dimensions may be changed.
+         * 
+         * Names of dimensions in this list are assumed to be unique.
+         */
+        val List<Dimension> dimensions
+        /**
+         * The list of constraints defining this polyhedron.
+         * 
+         * The list and its elements may be freely modified.
+         */
+        val List<LinearConstraint> constraints
+        /**
+         * The list of constraints that should be saturated (tightened)
+         * when a {@link PolyhedronSaturationOperator} is invoked.
+         * 
+         * This list may be freely modified.
+         * 
+         * Place all dimensions and constraints here to saturate all the bounds.
+         */
+        val List<LinearBoundedExpression> expressionsToSaturate
+        override toString() '''
+                Dimensions:
+                        «FOR dimension : dimensions»
+                                «dimension»
+                        «ENDFOR»
+                Constraints:
+                        «FOR constraint : constraints»
+                                «constraint»
+                        «ENDFOR»
+        '''
+        def createSignature() {
+                val size = dimensions.size + constraints.size
+                val lowerBounds = newArrayOfSize(size)
+                val upperBounds = newArrayOfSize(size)
+                var int i = 0
+                for (dimension : dimensions) {
+                        lowerBounds.set(i, dimension.lowerBound)
+                        upperBounds.set(i, dimension.upperBound)
+                        i++
+                }
+                for (constraint : constraints) {
+                        lowerBounds.set(i, constraint.lowerBound)
+                        upperBounds.set(i, constraint.upperBound)
+                        i++
+                }
+                new PolyhedronSignature.Bounds(lowerBounds, upperBounds)
+        }
+        def applySignature(PolyhedronSignature.Bounds signature) {
+                val lowerBounds = signature.lowerBounds
+                val upperBounds = signature.upperBounds
+                var int i = 0
+                for (dimension : dimensions) {
+                        dimension.lowerBound = lowerBounds.get(i)
+                        dimension.upperBound = upperBounds.get(i)
+                        i++
+                }
+                for (constraint : constraints) {
+                        constraint.lowerBound = lowerBounds.get(i)
+                        constraint.upperBound = upperBounds.get(i)
+                        i++
+                }
+        }
+}
+abstract class PolyhedronSignature {
+        public static val EMPTY = new PolyhedronSignature {
+                override toString() {
+                        "PolyhedronSignature.EMPTY"
+                }
+        }
+        private new() {
+        }
+        @Data
+        static class Bounds extends PolyhedronSignature {
+                val Integer[] lowerBounds
+                val Integer[] upperBounds
+        }
+}
+@Accessors
+abstract class LinearBoundedExpression {
+        var Integer lowerBound
+        var Integer upperBound
+        def void tightenLowerBound(Integer tighterBound) {
+                if (lowerBound === null || (tighterBound !== null && lowerBound < tighterBound)) {
+                        lowerBound = tighterBound
+                }
+        }
+        def void tightenUpperBound(Integer tighterBound) {
+                if (upperBound === null || (tighterBound !== null && upperBound > tighterBound)) {
+                        upperBound = tighterBound
+                }
+        }
+        def void assertEqualsTo(int bound) {
+                tightenLowerBound(bound)
+                tightenUpperBound(bound)
+        }
+}
+@Accessors
+class Dimension extends LinearBoundedExpression {
+        val String name
+        @FinalFieldsConstructor
+        new() {
+        }
+        new(String name, Integer lowerBound, Integer upperBound) {
+                this(name)
+                this.lowerBound = lowerBound
+                this.upperBound = upperBound
+        }
+        override toString() {
+                '''«IF lowerBound !== null»«lowerBound» <= «ENDIF»«name»«IF upperBound !== null» <= «upperBound»«ENDIF»'''
+        }
+}
+@Accessors
+class LinearConstraint extends LinearBoundedExpression {
+        val Map<Dimension, Integer> coefficients
+        @FinalFieldsConstructor
+        new() {
+        }
+        new(Map<Dimension, Integer> coefficients, Integer lowerBound, Integer upperBound) {
+                this(coefficients)
+                this.lowerBound = lowerBound
+                this.upperBound = upperBound
+        }
+        override toString() {
+                '''«IF lowerBound !== null»«lowerBound» <= «ENDIF»«FOR pair : coefficients.entrySet SEPARATOR " + "»«IF pair.value != 1»«pair.value» * «ENDIF»«pair.key.name»«ENDFOR»«IF upperBound !== null» <= «upperBound»«ENDIF»'''
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/RelationConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/RelationConstraintCalculator.xtend
new file mode 100644
index 00000000..3e4fea8a
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/RelationConstraintCalculator.xtend
@@ -0,0 +1,139 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.ImmutableSet
+import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion
+import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion
+import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.UpperMultiplicityAssertion
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
+import java.util.HashMap
+import java.util.List
+import org.eclipse.xtend.lib.annotations.Data
+@Data
+class RelationConstraints {
+        val List<RelationMultiplicityConstraint> multiplicityConstraints
+}
+@Data
+class RelationMultiplicityConstraint {
+        Relation relation
+        Relation inverseRelation
+        boolean containment
+        boolean container
+        int lowerBound
+        int upperBound
+        int inverseUpperBound
+        def isUpperBoundFinite() {
+                upperBound >= 0
+        }
+        private def isInverseUpperBoundFinite() {
+                inverseUpperBound >= 0
+        }
+        private def canHaveMultipleSourcesPerTarget() {
+                inverseUpperBound != 1
+        }
+        def constrainsUnfinished() {
+                lowerBound >= 1 && (!container || lowerBound >= 2)
+        }
+        def constrainsUnrepairable() {
+                // TODO Optimize the unrepairable matches computation,
+                // or come up with a heuristic when does computing unrepairables worth the overhead.
+                constrainsUnfinished && canHaveMultipleSourcesPerTarget && false
+        }
+        def constrainsRemainingInverse() {
+                lowerBound >= 1 && !containment && inverseUpperBoundFinite
+        }
+        def constrainsRemainingContents() {
+                containment
+        }
+        def isActive() {
+                constrainsUnfinished || constrainsUnrepairable || constrainsRemainingInverse || constrainsRemainingContents
+        }
+        def getSourceType() {
+                getParamType(0)
+        }
+        def getTargetType() {
+                getParamType(1)
+        }
+        private def getParamType(int i) {
+                val parameters = relation.parameters
+                if (i < parameters.size) {
+                        val firstParam = parameters.get(i)
+                        if (firstParam instanceof ComplexTypeReference) {
+                                return firstParam.referred
+                        }
+                }
+                throw new IllegalArgumentException("Constraint with unknown source type")
+        }
+}
+class RelationConstraintCalculator {
+        def calculateRelationConstraints(LogicProblem problem) {
+                val containmentRelations = switch (problem.containmentHierarchies.size) {
+                        case 0:
+                                <Relation>emptySet
+                        case 1:
+                                ImmutableSet.copyOf(problem.containmentHierarchies.head.containmentRelations)
+                        default:
+                                throw new IllegalArgumentException("Only a single containment hierarchy is supported")
+                }
+                val inverseRelations = new HashMap<Relation, Relation>
+                val lowerMultiplicities = new HashMap<Relation, Integer>
+                val upperMultiplicities = new HashMap<Relation, Integer>
+                for (relation : problem.relations) {
+                        lowerMultiplicities.put(relation, 0)
+                        upperMultiplicities.put(relation, -1)
+                }
+                for (annotation : problem.annotations) {
+                        switch (annotation) {
+                                InverseRelationAssertion: {
+                                        inverseRelations.put(annotation.inverseA, annotation.inverseB)
+                                        inverseRelations.put(annotation.inverseB, annotation.inverseA)
+                                }
+                                LowerMultiplicityAssertion:
+                                        lowerMultiplicities.put(annotation.relation, annotation.lower)
+                                UpperMultiplicityAssertion:
+                                        upperMultiplicities.put(annotation.relation, annotation.upper)
+                        }
+                }
+                val multiplicityConstraintsBuilder = ImmutableList.builder()
+                for (relation : problem.relations) {
+                        val containment = containmentRelations.contains(relation)
+                        val lowerMultiplicity = lowerMultiplicities.get(relation)
+                        val upperMultiplicity = upperMultiplicities.get(relation)
+                        var container = false
+                        var inverseUpperMultiplicity = -1
+                        val inverseRelation = inverseRelations.get(relation)
+                        if (inverseRelation !== null) {
+                                inverseUpperMultiplicity = upperMultiplicities.get(inverseRelation)
+                                container = containmentRelations.contains(inverseRelation)
+                        }
+                        if (containment) {
+                                inverseUpperMultiplicity = 1
+                        }
+                        val constraint = new RelationMultiplicityConstraint(relation, inverseRelation, containment, container,
+                                lowerMultiplicity, upperMultiplicity, inverseUpperMultiplicity)
+                        if (constraint.isActive) {
+                                if (relation.parameters.size != 2) {
+                                        throw new IllegalArgumentException('''Relation «relation.name» has multiplicity or containment constraints, but it is not binary''')
+                                }
+                                multiplicityConstraintsBuilder.add(constraint)
+                        }
+                }
+                new RelationConstraints(multiplicityConstraintsBuilder.build)
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagator.xtend
new file mode 100644
index 00000000..8f3a5bb0
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagator.xtend
@@ -0,0 +1,134 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope
+import java.util.HashMap
+import java.util.HashSet
+import java.util.Map
+import java.util.Set
+import org.eclipse.xtend.lib.annotations.Accessors
+class ScopePropagator {
+        @Accessors(PROTECTED_GETTER) val PartialInterpretation partialInterpretation
+        @Accessors(PROTECTED_GETTER) val ModelGenerationStatistics statistics
+        val Map<PartialTypeInterpratation, Scope> type2Scope
+        @Accessors(PROTECTED_GETTER) val Map<Scope, Set<Scope>> superScopes
+        @Accessors(PROTECTED_GETTER) val Map<Scope, Set<Scope>> subScopes
+        new(PartialInterpretation p, ModelGenerationStatistics statistics) {
+                partialInterpretation = p
+                this.statistics = statistics
+                type2Scope = new HashMap
+                for (scope : p.scopes) {
+                        type2Scope.put(scope.targetTypeInterpretation, scope)
+                }
+                superScopes = new HashMap
+                subScopes = new HashMap
+                for (scope : p.scopes) {
+                        superScopes.put(scope, new HashSet)
+                        subScopes.put(scope, new HashSet)
+                }
+                for (scope : p.scopes) {
+                        val target = scope.targetTypeInterpretation
+                        if (target instanceof PartialComplexTypeInterpretation) {
+                                val supertypeInterpretations = target.supertypeInterpretation
+                                for (supertypeInterpretation : supertypeInterpretations) {
+                                        val supertypeScope = type2Scope.get(supertypeInterpretation)
+                                        superScopes.get(scope).add(supertypeScope)
+                                        subScopes.get(supertypeScope).add(scope)
+                                }
+                        }
+                }
+                var boolean changed
+                do {
+                        changed = false
+                        for (scope : p.scopes) {
+                                val subScopeSet = subScopes.get(scope)
+                                val superScopeSet = superScopes.get(scope)
+                                for (subScope : subScopeSet) {
+                                        changed = changed || superScopes.get(subScope).addAll(superScopeSet)
+                                }
+                                for (superScope : superScopeSet) {
+                                        changed = changed || subScopes.get(superScope).addAll(subScopeSet)
+                                }
+                        }
+                } while (changed)
+                
+                copyScopeBoundsToHeuristic()
+        }
+        def propagateAllScopeConstraints() {
+                statistics.incrementScopePropagationCount()
+                doPropagateAllScopeConstraints()
+        }
+        
+        protected def copyScopeBoundsToHeuristic() {
+                partialInterpretation.minNewElementsHeuristic = partialInterpretation.minNewElements
+                for (scope : partialInterpretation.scopes) {
+                        scope.minNewElementsHeuristic = scope.minNewElements
+                }
+        }
+        protected def void doPropagateAllScopeConstraints() {
+                // Nothing to propagate.
+        }
+        def decrementTypeScope(PartialTypeInterpratation t) {
+//              println('''Adding to «(t as PartialComplexTypeInterpretation).interpretationOf.name»''')
+                val targetScope = type2Scope.get(t)
+                if (targetScope !== null) {
+                        targetScope.removeOne
+                        val sups = superScopes.get(targetScope)
+                        sups.forEach[removeOne]
+                }
+                if (this.partialInterpretation.minNewElements > 0) {
+                        this.partialInterpretation.minNewElements = this.partialInterpretation.minNewElements - 1
+                }
+                if (this.partialInterpretation.minNewElementsHeuristic > 0) {
+                        this.partialInterpretation.minNewElementsHeuristic = this.partialInterpretation.minNewElementsHeuristic - 1
+                }
+                if (this.partialInterpretation.maxNewElements > 0) {
+                        this.partialInterpretation.maxNewElements = this.partialInterpretation.maxNewElements - 1
+                } else if (this.partialInterpretation.maxNewElements === 0) {
+                        setScopesInvalid()
+                }
+//              println('''Target Scope: «targetScope.minNewElements» - «targetScope.maxNewElements»''')
+//              println(''' «this.partialInterpretation.minNewElements» - «this.partialInterpretation.maxNewElements»''')
+//              this.partialInterpretation.scopes.forEach[println(''' «(it.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name»: «it.minNewElements»-«it.maxNewElements»''')]
+//              println('''All constraints are propagated upon increasing «(t as PartialComplexTypeInterpretation).interpretationOf.name»''')
+        }
+        
+        protected def setScopesInvalid() {
+                partialInterpretation.minNewElements = Integer.MAX_VALUE
+                partialInterpretation.maxNewElements = 0
+                for (scope : partialInterpretation.scopes) {
+                        scope.minNewElements = Integer.MAX_VALUE
+                        scope.maxNewElements = 0
+                }
+        }
+        def void propagateAdditionToRelation(Relation r) {
+                // Nothing to propagate.
+        }
+        private def removeOne(Scope scope) {
+                if (scope.maxNewElements === 0) {
+                        throw new IllegalArgumentException('''Inconsistent object creation: «scope.targetTypeInterpretation»''')
+                } else if (scope.maxNewElements > 0) {
+                        scope.maxNewElements = scope.maxNewElements - 1
+                }
+                if (scope.minNewElements > 0) {
+                        scope.minNewElements = scope.minNewElements - 1
+                }
+                if (scope.minNewElementsHeuristic > 0) {
+                        scope.minNewElementsHeuristic = scope.minNewElementsHeuristic - 1
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagatorStrategy.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagatorStrategy.xtend
new file mode 100644
index 00000000..3165917a
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagatorStrategy.xtend
@@ -0,0 +1,71 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+import org.eclipse.xtend.lib.annotations.Data
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+enum PolyhedralScopePropagatorConstraints {
+        TypeHierarchy,
+        Relational
+}
+enum PolyhedralScopePropagatorSolver {
+        Z3Real,
+        Z3Integer,
+        Cbc,
+        Clp
+}
+abstract class ScopePropagatorStrategy {
+        public static val None = new Simple("None")
+        
+        public static val Basic = new Simple("Basic")
+        public static val BasicTypeHierarchy = new Simple("BasicTypeHierarchy")
+        private new() {
+        }
+        def boolean requiresUpperBoundIndexing()
+        static class Simple extends ScopePropagatorStrategy {
+                val String name
+                @FinalFieldsConstructor
+                private new() {
+                }
+                override requiresUpperBoundIndexing() {
+                        false
+                }
+                override toString() {
+                        name
+                }
+        }
+        @Data
+        static class Polyhedral extends ScopePropagatorStrategy {
+                public static val UNLIMITED_TIME = -1
+                val PolyhedralScopePropagatorConstraints constraints
+                val PolyhedralScopePropagatorSolver solver
+                val boolean updateHeuristic
+                val double timeoutSeconds
+                @FinalFieldsConstructor
+                new() {
+                }
+                new(PolyhedralScopePropagatorConstraints constraints, PolyhedralScopePropagatorSolver solver, boolean updateHeuristic) {
+                        this(constraints, solver, updateHeuristic, UNLIMITED_TIME)
+                }
+                
+                new(PolyhedralScopePropagatorConstraints constraints, PolyhedralScopePropagatorSolver solver) {
+                        this(constraints, solver, true)
+                }
+                override requiresUpperBoundIndexing() {
+                        constraints == PolyhedralScopePropagatorConstraints.Relational
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/TypeHierarchyScopePropagator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/TypeHierarchyScopePropagator.xtend
new file mode 100644
index 00000000..d1704b39
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/TypeHierarchyScopePropagator.xtend
@@ -0,0 +1,85 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope
+class TypeHierarchyScopePropagator extends ScopePropagator {
+        new(PartialInterpretation p, ModelGenerationStatistics statistics) {
+                super(p, statistics)
+        }
+        protected override doPropagateAllScopeConstraints() {
+                var boolean hadChanged
+                do {
+                        hadChanged = false
+                        for (superScopeEntry : superScopes.entrySet) {
+                                val sub = superScopeEntry.key
+                                hadChanged = propagateLowerLimitUp(sub, partialInterpretation) || hadChanged
+                                hadChanged = propagateUpperLimitDown(sub, partialInterpretation) || hadChanged
+                                for (sup : superScopeEntry.value) {
+                                        hadChanged = propagateLowerLimitUp(sub, sup) || hadChanged
+                                        hadChanged = propagateUpperLimitDown(sub, sup) || hadChanged
+                                }
+                        }
+                } while (hadChanged)
+        }
+        private def propagateLowerLimitUp(Scope subScope, Scope superScope) {
+                var changed = false
+                if (subScope.minNewElements > superScope.minNewElements) {
+                        superScope.minNewElements = subScope.minNewElements
+                        changed = true
+                }
+                if (subScope.minNewElementsHeuristic > superScope.minNewElementsHeuristic) {
+                        superScope.minNewElementsHeuristic = subScope.minNewElementsHeuristic
+                        changed = true
+                }
+                changed
+        }
+        private def propagateUpperLimitDown(Scope subScope, Scope superScope) {
+                if (superScope.maxNewElements >= 0 &&
+                        (superScope.maxNewElements < subScope.maxNewElements || subScope.maxNewElements < 0)) {
+//                      println('''
+//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> «(superScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name»
+//                      subScope.maxNewElements «subScope.maxNewElements» = superScope.maxNewElements «superScope.maxNewElements»
+//                      ''')
+                        subScope.maxNewElements = superScope.maxNewElements
+                        return true
+                } else {
+                        return false
+                }
+        }
+        private def propagateLowerLimitUp(Scope subScope, PartialInterpretation p) {
+                var changed = false
+                if (subScope.minNewElements > p.minNewElements) {
+//                      println('''
+//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> nodes
+//                      p.minNewElements «p.minNewElements» = subScope.minNewElements «subScope.minNewElements»
+//                      ''')
+                        p.minNewElements = subScope.minNewElements
+                        changed = true
+                }
+                if (subScope.minNewElementsHeuristic > p.minNewElementsHeuristic) {
+                        p.minNewElementsHeuristic = subScope.minNewElementsHeuristic
+                        changed = true
+                }
+                changed
+        }
+        private def propagateUpperLimitDown(Scope subScope, PartialInterpretation p) {
+                if (p.maxNewElements >= 0 && (p.maxNewElements < subScope.maxNewElements || subScope.maxNewElements < 0)) {
+//                      println('''
+//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> nodes
+//                      subScope.maxNewElements «subScope.maxNewElements» = p.maxNewElements «p.maxNewElements»
+//                      ''')
+                        subScope.maxNewElements = p.maxNewElements
+                        return true
+                } else {
+                        return false
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/Z3PolyhedronSolver.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/Z3PolyhedronSolver.xtend
new file mode 100644
index 00000000..3b831433
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/Z3PolyhedronSolver.xtend
@@ -0,0 +1,272 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+import com.microsoft.z3.AlgebraicNum
+import com.microsoft.z3.ArithExpr
+import com.microsoft.z3.Context
+import com.microsoft.z3.Expr
+import com.microsoft.z3.IntNum
+import com.microsoft.z3.Optimize
+import com.microsoft.z3.RatNum
+import com.microsoft.z3.Status
+import com.microsoft.z3.Symbol
+import java.math.BigDecimal
+import java.math.MathContext
+import java.math.RoundingMode
+import java.util.Map
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+class Z3PolyhedronSolver implements PolyhedronSolver {
+        val boolean lpRelaxation
+        val double timeoutSeconds
+        @FinalFieldsConstructor
+        new() {
+        }
+        new() {
+                this(false, -1)
+        }
+        override createSaturationOperator(Polyhedron polyhedron) {
+                new DisposingZ3SaturationOperator(this, polyhedron)
+        }
+        def createPersistentSaturationOperator(Polyhedron polyhedron) {
+                new Z3SaturationOperator(polyhedron, lpRelaxation, timeoutSeconds)
+        }
+}
+@FinalFieldsConstructor
+class DisposingZ3SaturationOperator implements PolyhedronSaturationOperator {
+        val Z3PolyhedronSolver solver
+        @Accessors val Polyhedron polyhedron
+        override saturate() {
+                val persistentOperator = solver.createPersistentSaturationOperator(polyhedron)
+                try {
+                        persistentOperator.saturate
+                } finally {
+                        persistentOperator.close
+                }
+        }
+        override close() throws Exception {
+                // Nothing to close.
+        }
+}
+class Z3SaturationOperator extends AbstractPolyhedronSaturationOperator {
+        static val INFINITY_SYMBOL_NAME = "oo"
+        static val MULT_SYMBOL_NAME = "*"
+        static val TIMEOUT_SYMBOL_NAME = "timeout"
+        static val INTEGER_PRECISION = new BigDecimal(Integer.MAX_VALUE).precision
+        static val ROUND_DOWN = new MathContext(INTEGER_PRECISION, RoundingMode.FLOOR)
+        static val ROUND_UP = new MathContext(INTEGER_PRECISION, RoundingMode.CEILING)
+        // The interval isolating the number is smaller than 1/10^precision. 
+        static val ALGEBRAIC_NUMBER_ROUNDING = 0
+        extension val Context context
+        val Symbol infinitySymbol
+        val Symbol multSymbol
+        val Map<Dimension, ArithExpr> variables
+        val int timeoutMilliseconds
+        new(Polyhedron polyhedron, boolean lpRelaxation, double timeoutSeconds) {
+                super(polyhedron)
+                context = new Context
+                infinitySymbol = context.mkSymbol(INFINITY_SYMBOL_NAME)
+                multSymbol = context.mkSymbol(MULT_SYMBOL_NAME)
+                variables = polyhedron.dimensions.toInvertedMap [ dimension |
+                        val name = dimension.name
+                        if (lpRelaxation) {
+                                mkRealConst(name)
+                        } else {
+                                mkIntConst(name)
+                        }
+                ]
+                timeoutMilliseconds = Math.ceil(timeoutSeconds * 1000) as int
+        }
+        override doSaturate() {
+                val status = executeSolver()
+                convertStatusToSaturationResult(status)
+        }
+        private def convertStatusToSaturationResult(Status status) {
+                switch (status) {
+                        case SATISFIABLE:
+                                PolyhedronSaturationResult.SATURATED
+                        case UNSATISFIABLE:
+                                PolyhedronSaturationResult.EMPTY
+                        case UNKNOWN:
+                                PolyhedronSaturationResult.UNKNOWN
+                        default:
+                                throw new IllegalArgumentException("Unknown Status: " + status)
+                }
+        }
+        private def executeSolver() {
+                for (expressionToSaturate : polyhedron.expressionsToSaturate) {
+                        val expr = expressionToSaturate.toExpr
+                        val lowerResult = saturateLowerBound(expr, expressionToSaturate)
+                        if (lowerResult != Status.SATISFIABLE) {
+                                return lowerResult
+                        }
+                        val upperResult = saturateUpperBound(expr, expressionToSaturate)
+                        if (upperResult != Status.SATISFIABLE) {
+                                return upperResult
+                        }
+                }
+                Status.SATISFIABLE
+        }
+        private def saturateLowerBound(ArithExpr expr, LinearBoundedExpression expressionToSaturate) {
+                val optimize = prepareOptimize
+                val handle = optimize.MkMinimize(expr)
+                val status = optimize.Check()
+                if (status == Status.SATISFIABLE) {
+                        val value = switch (resultExpr : handle.lower) {
+                                IntNum:
+                                        resultExpr.getInt()
+                                RatNum:
+                                        ceil(resultExpr)
+                                AlgebraicNum:
+                                        ceil(resultExpr.toUpper(ALGEBRAIC_NUMBER_ROUNDING))
+                                default:
+                                        if (isNegativeInfinity(resultExpr)) {
+                                                null
+                                        } else {
+                                                throw new IllegalArgumentException("Integer result expected, got: " + resultExpr)
+                                        }
+                        }
+                        expressionToSaturate.lowerBound = value
+                }
+                status
+        }
+        private def floor(RatNum ratNum) {
+                val numerator = new BigDecimal(ratNum.numerator.bigInteger)
+                val denominator = new BigDecimal(ratNum.denominator.bigInteger)
+                numerator.divide(denominator, ROUND_DOWN).setScale(0, RoundingMode.FLOOR).intValue
+        }
+        private def saturateUpperBound(ArithExpr expr, LinearBoundedExpression expressionToSaturate) {
+                val optimize = prepareOptimize
+                val handle = optimize.MkMaximize(expr)
+                val status = optimize.Check()
+                if (status == Status.SATISFIABLE) {
+                        val value = switch (resultExpr : handle.upper) {
+                                IntNum:
+                                        resultExpr.getInt()
+                                RatNum:
+                                        floor(resultExpr)
+                                AlgebraicNum:
+                                        floor(resultExpr.toLower(ALGEBRAIC_NUMBER_ROUNDING))
+                                default:
+                                        if (isPositiveInfinity(resultExpr)) {
+                                                null
+                                        } else {
+                                                throw new IllegalArgumentException("Integer result expected, got: " + resultExpr)
+                                        }
+                        }
+                        expressionToSaturate.upperBound = value
+                }
+                status
+        }
+        private def ceil(RatNum ratNum) {
+                val numerator = new BigDecimal(ratNum.numerator.bigInteger)
+                val denominator = new BigDecimal(ratNum.denominator.bigInteger)
+                numerator.divide(denominator, ROUND_UP).setScale(0, RoundingMode.CEILING).intValue
+        }
+        private def isPositiveInfinity(Expr expr) {
+                expr.app && expr.getFuncDecl.name == infinitySymbol
+        }
+        private def isNegativeInfinity(Expr expr) {
+                // Negative infinity is represented as (* (- 1) oo)
+                if (!expr.app || expr.getFuncDecl.name != multSymbol || expr.numArgs != 2) {
+                        return false
+                }
+                isPositiveInfinity(expr.args.get(1))
+        }
+        private def prepareOptimize() {
+                val optimize = mkOptimize()
+                if (timeoutMilliseconds >= 0) {
+                        val params = mkParams()
+                        // We cannot turn TIMEOUT_SYMBOL_NAME into a Symbol in the constructor,
+                        // because there is no add(Symbol, int) overload.
+                        params.add(TIMEOUT_SYMBOL_NAME, timeoutMilliseconds)
+                        optimize.parameters = params
+                }
+                assertConstraints(optimize)
+                optimize
+        }
+        private def assertConstraints(Optimize it) {
+                for (pair : variables.entrySet) {
+                        assertBounds(pair.value, pair.key)
+                }
+                for (constraint : nonTrivialConstraints) {
+                        val expr = createLinearCombination(constraint.coefficients)
+                        assertBounds(expr, constraint)
+                }
+        }
+        private def assertBounds(Optimize it, ArithExpr expression, LinearBoundedExpression bounds) {
+                val lowerBound = bounds.lowerBound
+                val upperBound = bounds.upperBound
+                if (lowerBound == upperBound) {
+                        if (lowerBound === null) {
+                                return
+                        }
+                        Assert(mkEq(expression, mkInt(lowerBound)))
+                } else {
+                        if (lowerBound !== null) {
+                                Assert(mkGe(expression, mkInt(lowerBound)))
+                        }
+                        if (upperBound !== null) {
+                                Assert(mkLe(expression, mkInt(upperBound)))
+                        }
+                }
+        }
+        private def toExpr(LinearBoundedExpression linearBoundedExpression) {
+                switch (linearBoundedExpression) {
+                        Dimension: variables.get(linearBoundedExpression)
+                        LinearConstraint: createLinearCombination(linearBoundedExpression.coefficients)
+                        default: throw new IllegalArgumentException("Unknown linear bounded expression:" + linearBoundedExpression)
+                }
+        }
+        private def createLinearCombination(Map<Dimension, Integer> coefficients) {
+                val size = coefficients.size
+                if (size == 0) {
+                        return mkInt(0)
+                }
+                val array = newArrayOfSize(size)
+                var int i = 0
+                for (pair : coefficients.entrySet) {
+                        val variable = variables.get(pair.key)
+                        if (variable === null) {
+                                throw new IllegalArgumentException("Unknown dimension: " + pair.key.name)
+                        }
+                        val coefficient = pair.value
+                        val term = if (coefficient == 1) {
+                                        variable
+                                } else {
+                                        mkMul(mkInt(coefficient), variable)
+                                }
+                        array.set(i, term)
+                        i++
+                }
+                mkAdd(array)
+        }
+        override close() throws Exception {
+                context.close()
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Interval.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Interval.xtend
new file mode 100644
index 00000000..691c8783
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Interval.xtend
@@ -0,0 +1,584 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval
+import java.math.BigDecimal
+import java.math.MathContext
+import java.math.RoundingMode
+import org.eclipse.xtend.lib.annotations.Data
+abstract class Interval implements Comparable<Interval> {
+        static val PRECISION = 32
+        package static val ROUND_DOWN = new MathContext(PRECISION, RoundingMode.FLOOR)
+        package static val ROUND_UP = new MathContext(PRECISION, RoundingMode.CEILING)
+        private new() {
+        }
+        abstract def boolean mustEqual(Interval other)
+        abstract def boolean mayEqual(Interval other)
+        def mustNotEqual(Interval other) {
+                !mayEqual(other)
+        }
+        def mayNotEqual(Interval other) {
+                !mustEqual(other)
+        }
+        abstract def boolean mustBeLessThan(Interval other)
+        abstract def boolean mayBeLessThan(Interval other)
+        def mustBeLessThanOrEqual(Interval other) {
+                !mayBeGreaterThan(other)
+        }
+        def mayBeLessThanOrEqual(Interval other) {
+                !mustBeGreaterThan(other)
+        }
+        def mustBeGreaterThan(Interval other) {
+                other.mustBeLessThan(this)
+        }
+        def mayBeGreaterThan(Interval other) {
+                other.mayBeLessThan(this)
+        }
+        def mustBeGreaterThanOrEqual(Interval other) {
+                other.mustBeLessThanOrEqual(this)
+        }
+        def mayBeGreaterThanOrEqual(Interval other) {
+                other.mayBeLessThanOrEqual(this)
+        }
+        abstract def Interval min(Interval other)
+        abstract def Interval max(Interval other)
+        abstract def Interval join(Interval other)
+        def +() {
+                this
+        }
+        abstract def Interval -()
+        abstract def Interval +(Interval other)
+        abstract def Interval -(Interval other)
+        abstract def Interval *(int count)
+        abstract def Interval *(Interval other)
+        abstract def Interval /(Interval other)
+        abstract def Interval **(Interval other)
+        public static val EMPTY = new Interval {
+                override mustEqual(Interval other) {
+                        true
+                }
+                override mayEqual(Interval other) {
+                        false
+                }
+                override mustBeLessThan(Interval other) {
+                        true
+                }
+                override mayBeLessThan(Interval other) {
+                        false
+                }
+                override min(Interval other) {
+                        EMPTY
+                }
+                override max(Interval other) {
+                        EMPTY
+                }
+                override join(Interval other) {
+                        other
+                }
+                override -() {
+                        EMPTY
+                }
+                override +(Interval other) {
+                        EMPTY
+                }
+                override -(Interval other) {
+                        EMPTY
+                }
+                override *(int count) {
+                        EMPTY
+                }
+                override *(Interval other) {
+                        EMPTY
+                }
+                override /(Interval other) {
+                        EMPTY
+                }
+                override **(Interval other) {
+                        EMPTY
+                }
+                override toString() {
+                        "∅"
+                }
+                override compareTo(Interval o) {
+                        if (o == EMPTY) {
+                                0
+                        } else {
+                                -1
+                        }
+                }
+        }
+        public static val Interval ZERO = new NonEmpty(BigDecimal.ZERO, BigDecimal.ZERO)
+        public static val Interval UNBOUNDED = new NonEmpty(null, null)
+        static def Interval of(BigDecimal lower, BigDecimal upper) {
+                new NonEmpty(lower, upper)
+        }
+        static def between(double lower, double upper) {
+                of(new BigDecimal(lower, ROUND_DOWN), new BigDecimal(upper, ROUND_UP))
+        }
+        static def upTo(double upper) {
+                of(null, new BigDecimal(upper, ROUND_UP))
+        }
+        static def above(double lower) {
+                of(new BigDecimal(lower, ROUND_DOWN), null)
+        }
+        @Data
+        private static class NonEmpty extends Interval {
+                val BigDecimal lower
+                val BigDecimal upper
+                /**
+                 * Construct a new non-empty interval.
+                 * 
+                 * @param lower The lower bound of the interval. Use <code>null</code> for negative infinity.
+                 * @param upper The upper bound of the interval. Use <code>null</code> for positive infinity.
+                 */
+                new(BigDecimal lower, BigDecimal upper) {
+                        if (lower !== null && upper !== null && lower > upper) {
+                                throw new IllegalArgumentException("Lower bound of interval must not be larger than upper bound")
+                        }
+                        this.lower = lower
+                        this.upper = upper
+                }
+                override mustEqual(Interval other) {
+                        switch (other) {
+                                case EMPTY: true
+                                NonEmpty: lower == upper && lower == other.lower && lower == other.upper
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+                override mayEqual(Interval other) {
+                        if (other instanceof NonEmpty) {
+                                (lower === null || other.upper === null || lower <= other.upper) &&
+                                        (other.lower === null || upper === null || other.lower <= upper)
+                        } else {
+                                false
+                        }
+                }
+                override mustBeLessThan(Interval other) {
+                        switch (other) {
+                                case EMPTY: true
+                                NonEmpty: upper !== null && other.lower !== null && upper < other.lower
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+                override mayBeLessThan(Interval other) {
+                        if (other instanceof NonEmpty) {
+                                lower === null || other.upper === null || lower < other.upper
+                        } else {
+                                false
+                        }
+                }
+                override min(Interval other) {
+                        switch (other) {
+                                case EMPTY: this
+                                NonEmpty: min(other)
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+                def min(NonEmpty other) {
+                        new NonEmpty(
+                                lower.tryMin(other.lower),
+                                if(other.upper === null) upper else if(upper === null) other.upper else upper.min(other.upper)
+                        )
+                }
+                override max(Interval other) {
+                        switch (other) {
+                                case EMPTY: this
+                                NonEmpty: max(other)
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+                def max(NonEmpty other) {
+                        new NonEmpty(
+                                if(other.lower === null) lower else if(lower === null) other.lower else lower.max(other.lower),
+                                upper.tryMax(other.upper)
+                        )
+                }
+                override join(Interval other) {
+                        switch (other) {
+                                case EMPTY: this
+                                NonEmpty: new NonEmpty(lower.tryMin(other.lower), upper.tryMax(other.upper))
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+                override -() {
+                        new NonEmpty(upper?.negate(ROUND_DOWN), lower?.negate(ROUND_UP))
+                }
+                override +(Interval other) {
+                        switch (other) {
+                                case EMPTY: EMPTY
+                                NonEmpty: this + other
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+                def +(NonEmpty other) {
+                        new NonEmpty(
+                                lower.tryAdd(other.lower, ROUND_DOWN),
+                                upper.tryAdd(other.upper, ROUND_UP)
+                        )
+                }
+                private static def tryAdd(BigDecimal a, BigDecimal b, MathContext mc) {
+                        if (b === null) {
+                                null
+                        } else {
+                                a?.add(b, mc)
+                        }
+                }
+                override -(Interval other) {
+                        switch (other) {
+                                case EMPTY: EMPTY
+                                NonEmpty: this - other
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+                def -(NonEmpty other) {
+                        new NonEmpty(
+                                lower.trySubtract(other.upper, ROUND_DOWN),
+                                upper.trySubtract(other.lower, ROUND_UP)
+                        )
+                }
+                private static def trySubtract(BigDecimal a, BigDecimal b, MathContext mc) {
+                        if (b === null) {
+                                null
+                        } else {
+                                a?.subtract(b, mc)
+                        }
+                }
+                override *(int count) {
+                        val bigCount = new BigDecimal(count)
+                        new NonEmpty(
+                                lower.tryMultiply(bigCount, ROUND_DOWN),
+                                upper.tryMultiply(bigCount, ROUND_UP)
+                        )
+                }
+                override *(Interval other) {
+                        switch (other) {
+                                case EMPTY: EMPTY
+                                NonEmpty: this * other
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+                def *(NonEmpty other) {
+                        if (this == ZERO || other == ZERO) {
+                                ZERO
+                        } else if (nonpositive) {
+                                if (other.nonpositive) {
+                                        new NonEmpty(
+                                                upper.multiply(other.upper, ROUND_DOWN),
+                                                lower.tryMultiply(other.lower, ROUND_UP)
+                                        )
+                                } else if (other.nonnegative) {
+                                        new NonEmpty(
+                                                lower.tryMultiply(other.upper, ROUND_DOWN),
+                                                upper.multiply(other.lower, ROUND_UP)
+                                        )
+                                } else {
+                                        new NonEmpty(
+                                                lower.tryMultiply(other.upper, ROUND_DOWN),
+                                                lower.tryMultiply(other.lower, ROUND_UP)
+                                        )
+                                }
+                        } else if (nonnegative) {
+                                if (other.nonpositive) {
+                                        new NonEmpty(
+                                                upper.tryMultiply(other.lower, ROUND_DOWN),
+                                                lower.multiply(other.upper, ROUND_UP)
+                                        )
+                                } else if (other.nonnegative) {
+                                        new NonEmpty(
+                                                lower.multiply(other.lower, ROUND_DOWN),
+                                                upper.tryMultiply(other.upper, ROUND_UP)
+                                        )
+                                } else {
+                                        new NonEmpty(
+                                                upper.tryMultiply(other.lower, ROUND_DOWN),
+                                                upper.tryMultiply(other.upper, ROUND_UP)
+                                        )
+                                }
+                        } else {
+                                if (other.nonpositive) {
+                                        new NonEmpty(
+                                                upper.tryMultiply(other.lower, ROUND_DOWN),
+                                                lower.tryMultiply(other.lower, ROUND_UP)
+                                        )
+                                } else if (other.nonnegative) {
+                                        new NonEmpty(
+                                                lower.tryMultiply(other.upper, ROUND_DOWN),
+                                                upper.tryMultiply(other.upper, ROUND_UP)
+                                        )
+                                } else {
+                                        new NonEmpty(
+                                                lower.tryMultiply(other.upper, ROUND_DOWN).tryMin(upper.tryMultiply(other.lower, ROUND_DOWN)),
+                                                lower.tryMultiply(other.lower, ROUND_UP).tryMax(upper.tryMultiply(other.upper, ROUND_UP))
+                                        )
+                                }
+                        }
+                }
+                private def isNonpositive() {
+                        upper !== null && upper <= BigDecimal.ZERO
+                }
+                private def isNonnegative() {
+                        lower !== null && lower >= BigDecimal.ZERO
+                }
+                private static def tryMultiply(BigDecimal a, BigDecimal b, MathContext mc) {
+                        if (b === null) {
+                                null
+                        } else {
+                                a?.multiply(b, mc)
+                        }
+                }
+                private static def tryMin(BigDecimal a, BigDecimal b) {
+                        if (b === null) {
+                                null
+                        } else {
+                                a?.min(b)
+                        }
+                }
+                private static def tryMax(BigDecimal a, BigDecimal b) {
+                        if (b === null) {
+                                null
+                        } else {
+                                a?.max(b)
+                        }
+                }
+                override /(Interval other) {
+                        switch (other) {
+                                case EMPTY: EMPTY
+                                NonEmpty: this / other
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+                def /(NonEmpty other) {
+                        if (other == ZERO) {
+                                EMPTY
+                        } else if (this == ZERO) {
+                                ZERO
+                        } else if (other.strictlyNegative) {
+                                if (nonpositive) {
+                                        new NonEmpty(
+                                                upper.tryDivide(other.lower, ROUND_DOWN),
+                                                lower.tryDivide(other.upper, ROUND_UP)
+                                        )
+                                } else if (nonnegative) {
+                                        new NonEmpty(
+                                                upper.tryDivide(other.upper, ROUND_DOWN),
+                                                lower.tryDivide(other.lower, ROUND_UP)
+                                        )
+                                } else { // lower < 0 < upper
+                                        new NonEmpty(
+                                                upper.tryDivide(other.upper, ROUND_DOWN),
+                                                lower.tryDivide(other.upper, ROUND_UP)
+                                        )
+                                }
+                        } else if (other.strictlyPositive) {
+                                if (nonpositive) {
+                                        new NonEmpty(
+                                                lower.tryDivide(other.lower, ROUND_DOWN),
+                                                upper.tryDivide(other.upper, ROUND_UP)
+                                        )
+                                } else if (nonnegative) {
+                                        new NonEmpty(
+                                                lower.tryDivide(other.upper, ROUND_DOWN),
+                                                upper.tryDivide(other.lower, ROUND_UP)
+                                        )
+                                } else { // lower < 0 < upper
+                                        new NonEmpty(
+                                                lower.tryDivide(other.lower, ROUND_DOWN),
+                                                upper.tryDivide(other.lower, ROUND_UP)
+                                        )
+                                }
+                        } else { // other contains 0
+                                if (other.lower == BigDecimal.ZERO) { // 0 == other.lower < other.upper, because [0, 0] was exluded earlier
+                                        if (nonpositive) {
+                                                new NonEmpty(null, upper.tryDivide(other.upper, ROUND_UP))
+                                        } else if (nonnegative) {
+                                                new NonEmpty(lower.tryDivide(other.upper, ROUND_DOWN), null)
+                                        } else { // lower < 0 < upper
+                                                UNBOUNDED
+                                        }
+                                } else if (other.upper == BigDecimal.ZERO) { // other.lower < other.upper == 0
+                                        if (nonpositive) {
+                                                new NonEmpty(upper.tryDivide(other.lower, ROUND_DOWN), null)
+                                        } else if (nonnegative) {
+                                                new NonEmpty(null, lower.tryDivide(other.lower, ROUND_UP))
+                                        } else { // lower < 0 < upper
+                                                UNBOUNDED
+                                        }
+                                } else { // other.lower < 0 < other.upper
+                                        UNBOUNDED
+                                }
+                        }
+                }
+                private def isStrictlyNegative() {
+                        upper !== null && upper < BigDecimal.ZERO
+                }
+                private def isStrictlyPositive() {
+                        lower !== null && lower > BigDecimal.ZERO
+                }
+                private static def tryDivide(BigDecimal a, BigDecimal b, MathContext mc) {
+                        if (b === null) {
+                                BigDecimal.ZERO
+                        } else {
+                                a?.divide(b, mc)
+                        }
+                }
+                override **(Interval other) {
+                        switch (other) {
+                                case EMPTY: EMPTY
+                                NonEmpty: this ** other
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+                def **(NonEmpty other) {
+                        // XXX This should use proper rounding for log and exp instead of
+                        // converting to double.
+                        // XXX We should not ignore (integer) powers of negative numbers.
+                        val lowerLog = if (lower === null || lower <= BigDecimal.ZERO) {
+                                        null
+                                } else {
+                                        new BigDecimal(Math.log(lower.doubleValue), ROUND_DOWN)
+                                }
+                        val upperLog = if (upper === null) {
+                                        null
+                                } else if (upper == BigDecimal.ZERO) {
+                                        return ZERO
+                                } else if (upper < BigDecimal.ZERO) {
+                                        return EMPTY
+                                } else {
+                                        new BigDecimal(Math.log(upper.doubleValue), ROUND_UP)
+                                }
+                        val log = new NonEmpty(lowerLog, upperLog)
+                        val product = log * other
+                        if (product instanceof NonEmpty) {
+                                val lowerResult = if (product.lower === null) {
+                                                BigDecimal.ZERO
+                                        } else {
+                                                new BigDecimal(Math.exp(product.lower.doubleValue), ROUND_DOWN)
+                                        }
+                                val upperResult = if (product.upper === null) {
+                                                null
+                                        } else {
+                                                new BigDecimal(Math.exp(product.upper.doubleValue), ROUND_UP)
+                                        }
+                                new NonEmpty(lowerResult, upperResult)
+                        } else {
+                                throw new IllegalArgumentException("Unknown interval: " + product)
+                        }
+                }
+                override toString() {
+                        '''«IF lower === null»(-∞«ELSE»[«lower»«ENDIF», «IF upper === null»∞)«ELSE»«upper»]«ENDIF»'''
+                }
+                override compareTo(Interval o) {
+                        switch (o) {
+                                case EMPTY: 1
+                                NonEmpty: compareTo(o)
+                                default: throw new IllegalArgumentException("Unknown interval: " + o)
+                        }
+                }
+                def compareTo(NonEmpty o) {
+                        if (lower === null) {
+                                if (o.lower !== null) {
+                                        return -1
+                                }
+                        } else if (o.lower === null) { // lower !== null
+                                return 1
+                        } else { // both lower and o.lower are finite
+                                val lowerDifference = lower.compareTo(o.lower)
+                                if (lowerDifference != 0) {
+                                        return lowerDifference
+                                }
+                        }
+                        if (upper === null) {
+                                if (o.upper === null) {
+                                        return 0
+                                } else {
+                                        return 1
+                                }
+                        } else if (o.upper === null) { // upper !== null
+                                return -1
+                        }
+                        upper.compareTo(o.upper)
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationMode.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationMode.java
new file mode 100644
index 00000000..f106e305
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationMode.java
@@ -0,0 +1,99 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval;
+import java.util.function.BinaryOperator;
+public enum IntervalAggregationMode implements BinaryOperator<Interval> {
+        SUM("intervalSum", "Sum a set of intervals") {
+                @Override
+                public IntervalRedBlackNode createNode(Interval interval) {
+                        return new IntervalRedBlackNode(interval) {
+                                public boolean isMultiplicitySensitive() {
+                                        return true;
+                                }
+                                public Interval multiply(Interval interval, int count) {
+                                        return interval.operator_multiply(count);
+                                };
+                                @Override
+                                public Interval op(Interval left, Interval right) {
+                                        return left.operator_plus(right);
+                                }
+                        };
+                }
+                
+                @Override
+                public Interval getNeutral() {
+                        return Interval.ZERO;
+                }
+        },
+        
+        MIN("intervalMin", "Find the minimum a set of intervals") {
+                @Override
+                public IntervalRedBlackNode createNode(Interval interval) {
+                        return new IntervalRedBlackNode(interval) {
+                                @Override
+                                public Interval op(Interval left, Interval right) {
+                                        return left.min(right);
+                                }
+                        };
+                }
+        },
+        
+        MAX("intervalMax", "Find the maximum a set of intervals") {
+                @Override
+                public IntervalRedBlackNode createNode(Interval interval) {
+                        return new IntervalRedBlackNode(interval) {
+                                @Override
+                                public Interval op(Interval left, Interval right) {
+                                        return left.max(right);
+                                }
+                        };
+                }
+        },
+        JOIN("intervalJoin", "Calculate the smallest interval containing all the intervals in a set") {
+                @Override
+                public IntervalRedBlackNode createNode(Interval interval) {
+                        return new IntervalRedBlackNode(interval) {
+                                @Override
+                                public Interval op(Interval left, Interval right) {
+                                        return left.join(right);
+                                }
+                        };
+                }
+        };
+        private final String modeName;
+        private final String description;
+        private final IntervalRedBlackNode empty;
+        IntervalAggregationMode(String modeName, String description) {
+                this.modeName = modeName;
+                this.description = description;
+                empty = createNode(null);
+        }
+        public String getModeName() {
+                return modeName;
+        }
+        public String getDescription() {
+                return description;
+        }
+        public IntervalRedBlackNode getEmpty() {
+                return empty;
+        }
+        @Override
+        public Interval apply(Interval left, Interval right) {
+                return empty.op(left, right);
+        }
+        public abstract IntervalRedBlackNode createNode(Interval interval);
+        
+        public Interval getNeutral() {
+                return Interval.EMPTY;
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationOperator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationOperator.xtend
new file mode 100644
index 00000000..21d3d73b
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationOperator.xtend
@@ -0,0 +1,48 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval
+import java.util.stream.Stream
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+@FinalFieldsConstructor
+class IntervalAggregationOperator implements IMultisetAggregationOperator<Interval, IntervalRedBlackNode, Interval> {
+        @Accessors val IntervalAggregationMode mode
+        override getName() {
+                mode.modeName
+        }
+        override getShortDescription() {
+                mode.description
+        }
+        override createNeutral() {
+                mode.empty
+        }
+        override isNeutral(IntervalRedBlackNode result) {
+                result.leaf
+        }
+        override update(IntervalRedBlackNode oldResult, Interval updateValue, boolean isInsertion) {
+                if (isInsertion) {
+                        val newNode = mode.createNode(updateValue)
+                        oldResult.add(newNode)
+                } else {
+                        oldResult.remove(updateValue)
+                }
+        }
+        override getAggregate(IntervalRedBlackNode result) {
+                if (result.leaf) {
+                        mode.neutral
+                } else {
+                        result.result
+                }
+        }
+        override aggregateStream(Stream<Interval> stream) {
+                stream.reduce(mode).orElse(mode.neutral)
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalHullAggregatorOperator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalHullAggregatorOperator.xtend
new file mode 100644
index 00000000..ce48eca1
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalHullAggregatorOperator.xtend
@@ -0,0 +1,87 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval
+import java.math.BigDecimal
+import java.math.MathContext
+import java.util.SortedMap
+import java.util.TreeMap
+import java.util.stream.Stream
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator
+abstract class IntervalHullAggregatorOperator<T extends Comparable<T>> implements IMultisetAggregationOperator<T, SortedMap<T, Integer>, Interval> {
+        protected new() {
+        }
+        
+        override getName() {
+                "intervalHull"
+        }
+        override getShortDescription() {
+                "Calculates the interval hull of a set of numbers"
+        }
+        override createNeutral() {
+                new TreeMap
+        }
+        override getAggregate(SortedMap<T, Integer> result) {
+                if (result.neutral) {
+                        Interval.EMPTY
+                } else {
+                        toInterval(result.firstKey, result.lastKey)
+                }
+        }
+        
+        protected abstract def BigDecimal toBigDecimal(T value, MathContext mc)
+        
+        private def toInterval(T min, T max) {
+                Interval.of(min.toBigDecimal(Interval.ROUND_DOWN), max.toBigDecimal(Interval.ROUND_UP))
+        }
+        override isNeutral(SortedMap<T, Integer> result) {
+                result.empty
+        }
+        override update(SortedMap<T, Integer> oldResult, T updateValue, boolean isInsertion) {
+                if (isInsertion) {
+                        oldResult.compute(updateValue) [ key, value |
+                                if (value === null) {
+                                        1
+                                } else if (value > 0) {
+                                        value + 1
+                                } else {
+                                        throw new IllegalStateException("Invalid count: " + value)
+                                }
+                        ]
+                } else {
+                        oldResult.compute(updateValue) [ key, value |
+                                if (value === 1) {
+                                        null
+                                } else if (value > 1) {
+                                        value - 1
+                                } else {
+                                        throw new IllegalStateException("Invalid count: " + value)
+                                }
+                        ]
+                }
+                oldResult
+        }
+        override aggregateStream(Stream<T> stream) {
+                val iterator = stream.iterator
+                if (!iterator.hasNext) {
+                        return Interval.EMPTY
+                }
+                var min = iterator.next
+                var max = min
+                while (iterator.hasNext) {
+                        val element = iterator.next
+                        if (element.compareTo(min) < 0) {
+                                min = element
+                        }
+                        if (element.compareTo(max) > 0) {
+                                max = element
+                        }
+                }
+                toInterval(min, max)
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalRedBlackNode.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalRedBlackNode.xtend
new file mode 100644
index 00000000..3aa575bc
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalRedBlackNode.xtend
@@ -0,0 +1,177 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval
+abstract class IntervalRedBlackNode extends RedBlackNode<IntervalRedBlackNode> {
+        public val Interval interval
+        public var int count = 1
+        public var Interval result
+        new(Interval interval) {
+                this.interval = interval
+        }
+        def boolean isMultiplicitySensitive() {
+                false
+        }
+        def Interval multiply(Interval interval, int count) {
+                interval
+        }
+        abstract def Interval op(Interval left, Interval right)
+        override augment() {
+                val value = calcualteAugmentation()
+                if (result == value) {
+                        false
+                } else {
+                        result = value
+                        true
+                }
+        }
+        private def calcualteAugmentation() {
+                var value = multiply(interval, count)
+                if (!left.leaf) {
+                        value = op(value, left.result)
+                }
+                if (!right.leaf) {
+                        value = op(value, right.result)
+                }
+                value
+        }
+        override assertNodeIsValid() {
+                super.assertNodeIsValid()
+                if (leaf) {
+                        return
+                }
+                if (count <= 0) {
+                        throw new IllegalStateException("Node with nonpositive count")
+                }
+                val value = calcualteAugmentation()
+                if (result != value) {
+                        throw new IllegalStateException("Node with invalid augmentation: " + result + " != " + value)
+                }
+        }
+        override assertSubtreeIsValid() {
+                super.assertSubtreeIsValid()
+                assertNodeIsValid()
+        }
+        override compareTo(IntervalRedBlackNode other) {
+                if (leaf || other.leaf) {
+                        throw new IllegalArgumentException("One of the nodes is a leaf node")
+                }
+                interval.compareTo(other.interval)
+        }
+        def add(IntervalRedBlackNode newNode) {
+                if (parent !== null) {
+                        throw new IllegalArgumentException("This is not the root of a tree")
+                }
+                if (leaf) {
+                        newNode.isRed = false
+                        newNode.left = this
+                        newNode.right = this
+                        newNode.parent = null
+                        newNode.augment
+                        return newNode
+                }
+                val modifiedNode = addWithoutFixup(newNode)
+                if (modifiedNode === newNode) {
+                        // Must augment here, because fixInsertion() might call augment()
+                        // on a node repeatedly, which might lose the change notification the
+                        // second time it is called, and the augmentation will fail to
+                        // reach the root.
+                        modifiedNode.augmentRecursively
+                        modifiedNode.isRed = true
+                        return modifiedNode.fixInsertion
+                }
+                if (multiplicitySensitive) {
+                        modifiedNode.augmentRecursively
+                }
+                this
+        }
+        private def addWithoutFixup(IntervalRedBlackNode newNode) {
+                var node = this
+                while (!node.leaf) {
+                        val comparison = node.interval.compareTo(newNode.interval)
+                        if (comparison < 0) {
+                                if (node.left.leaf) {
+                                        newNode.left = node.left
+                                        newNode.right = node.left
+                                        node.left = newNode
+                                        newNode.parent = node
+                                        return newNode
+                                } else {
+                                        node = node.left
+                                }
+                        } else if (comparison > 0) {
+                                if (node.right.leaf) {
+                                        newNode.left = node.right
+                                        newNode.right = node.right
+                                        node.right = newNode
+                                        newNode.parent = node
+                                        return newNode
+                                } else {
+                                        node = node.right
+                                }
+                        } else { // comparison == 0
+                                newNode.parent = null
+                                node.count++
+                                return node
+                        }
+                }
+                throw new IllegalStateException("Reached leaf node while searching for insertion point")
+        }
+        private def augmentRecursively() {
+                for (var node = this; node !== null; node = node.parent) {
+                        if (!node.augment) {
+                                return
+                        }
+                }
+        }
+        def remove(Interval interval) {
+                val node = find(interval)
+                node.count--
+                if (node.count == 0) {
+                        return node.remove
+                }
+                if (multiplicitySensitive) {
+                        node.augmentRecursively
+                }
+                this
+        }
+        private def find(Interval interval) {
+                var node = this
+                while (!node.leaf) {
+                        val comparison = node.interval.compareTo(interval)
+                        if (comparison < 0) {
+                                node = node.left
+                        } else if (comparison > 0) {
+                                node = node.right
+                        } else { // comparison == 0
+                                return node
+                        }
+                }
+                throw new IllegalStateException("Reached leaf node while searching for interval to remove")
+        }
+        override toString() {
+                if (leaf) {
+                        "L"
+                } else {
+                        '''
+                                «IF isRed»R«ELSE»B«ENDIF» «count»«interval» : «result»
+                                        «left»
+                                        «right»
+                        '''
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/RedBlackNode.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/RedBlackNode.java
new file mode 100644
index 00000000..8c40816b
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/RedBlackNode.java
@@ -0,0 +1,1392 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 btrekkie
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval;
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+/**
+ * A node in a red-black tree ( https://en.wikipedia.org/wiki/Red%E2%80%93black_tree ). Compared to a class like Java's
+ * TreeMap, RedBlackNode is a low-level data structure. The internals of a node are exposed as public fields, allowing
+ * clients to directly observe and manipulate the structure of the tree. This gives clients flexibility, although it
+ * also enables them to violate the red-black or BST properties. The RedBlackNode class provides methods for performing
+ * various standard operations, such as insertion and removal.
+ *
+ * Unlike most implementations of binary search trees, RedBlackNode supports arbitrary augmentation. By subclassing
+ * RedBlackNode, clients can add arbitrary data and augmentation information to each node. For example, if we were to
+ * use a RedBlackNode subclass to implement a sorted set, the subclass would have a field storing an element in the set.
+ * If we wanted to keep track of the number of non-leaf nodes in each subtree, we would store this as a "size" field and
+ * override augment() to update this field. All RedBlackNode methods (such as "insert" and remove()) call augment() as
+ * necessary to correctly maintain the augmentation information, unless otherwise indicated.
+ *
+ * The values of the tree are stored in the non-leaf nodes. RedBlackNode does not support use cases where values must be
+ * stored in the leaf nodes. It is recommended that all of the leaf nodes in a given tree be the same (black)
+ * RedBlackNode instance, to save space. The root of an empty tree is a leaf node, as opposed to null.
+ *
+ * For reference, a red-black tree is a binary search tree satisfying the following properties:
+ *
+ * - Every node is colored red or black.
+ * - The leaf nodes, which are dummy nodes that do not store any values, are colored black.
+ * - The root is black.
+ * - Both children of each red node are black.
+ * - Every path from the root to a leaf contains the same number of black nodes.
+ *
+ * @param <N> The type of node in the tree. For example, we might have
+ *     "class FooNode<T> extends RedBlackNode<FooNode<T>>".
+ * @author Bill Jacobs
+ */
+public abstract class RedBlackNode<N extends RedBlackNode<N>> implements Comparable<N> {
+    /** A Comparator that compares Comparable elements using their natural order. */
+    private static final Comparator<Comparable<Object>> NATURAL_ORDER = new Comparator<Comparable<Object>>() {
+        @Override
+        public int compare(Comparable<Object> value1, Comparable<Object> value2) {
+            return value1.compareTo(value2);
+        }
+    };
+    /** The parent of this node, if any.  "parent" is null if this is a leaf node. */
+    public N parent;
+    /** The left child of this node.  "left" is null if this is a leaf node. */
+    public N left;
+    /** The right child of this node.  "right" is null if this is a leaf node. */
+    public N right;
+    /** Whether the node is colored red, as opposed to black. */
+    public boolean isRed;
+    /**
+     * Sets any augmentation information about the subtree rooted at this node that is stored in this node.  For
+     * example, if we augment each node by subtree size (the number of non-leaf nodes in the subtree), this method would
+     * set the size field of this node to be equal to the size field of the left child plus the size field of the right
+     * child plus one.
+     *
+     * "Augmentation information" is information that we can compute about a subtree rooted at some node, preferably
+     * based only on the augmentation information in the node's two children and the information in the node.  Examples
+     * of augmentation information are the sum of the values in a subtree and the number of non-leaf nodes in a subtree.
+     * Augmentation information may not depend on the colors of the nodes.
+     *
+     * This method returns whether the augmentation information in any of the ancestors of this node might have been
+     * affected by changes in this subtree since the last call to augment().  In the usual case, where the augmentation
+     * information depends only on the information in this node and the augmentation information in its immediate
+     * children, this is equivalent to whether the augmentation information changed as a result of this call to
+     * augment().  For example, in the case of subtree size, this returns whether the value of the size field prior to
+     * calling augment() differed from the size field of the left child plus the size field of the right child plus one.
+     * False positives are permitted.  The return value is unspecified if we have not called augment() on this node
+     * before.
+     *
+     * This method may assume that this is not a leaf node.  It may not assume that the augmentation information stored
+     * in any of the tree's nodes is correct.  However, if the augmentation information stored in all of the node's
+     * descendants is correct, then the augmentation information stored in this node must be correct after calling
+     * augment().
+     */
+    public boolean augment() {
+        return false;
+    }
+    /**
+     * Throws a RuntimeException if we detect that this node locally violates any invariants specific to this subclass
+     * of RedBlackNode.  For example, if this stores the size of the subtree rooted at this node, this should throw a
+     * RuntimeException if the size field of this is not equal to the size field of the left child plus the size field
+     * of the right child plus one.  Note that we may call this on a leaf node.
+     *
+     * assertSubtreeIsValid() calls assertNodeIsValid() on each node, or at least starts to do so until it detects a
+     * problem.  assertNodeIsValid() should assume the node is in a tree that satisfies all properties common to all
+     * red-black trees, as assertSubtreeIsValid() is responsible for such checks.  assertNodeIsValid() should be
+     * "downward-looking", i.e. it should ignore any information in "parent", and it should be "local", i.e. it should
+     * only check a constant number of descendants.  To include "global" checks, such as verifying the BST property
+     * concerning ordering, override assertSubtreeIsValid().  assertOrderIsValid is useful for checking the BST
+     * property.
+     */
+    public void assertNodeIsValid() {
+    }
+    /** Returns whether this is a leaf node. */
+    public boolean isLeaf() {
+        return left == null;
+    }
+    /** Returns the root of the tree that contains this node. */
+    public N root() {
+        @SuppressWarnings("unchecked")
+        N node = (N)this;
+        while (node.parent != null) {
+            node = node.parent;
+        }
+        return node;
+    }
+    /** Returns the first node in the subtree rooted at this node, if any. */
+    public N min() {
+        if (isLeaf()) {
+            return null;
+        }
+        @SuppressWarnings("unchecked")
+        N node = (N)this;
+        while (!node.left.isLeaf()) {
+            node = node.left;
+        }
+        return node;
+    }
+    /** Returns the last node in the subtree rooted at this node, if any. */
+    public N max() {
+        if (isLeaf()) {
+            return null;
+        }
+        @SuppressWarnings("unchecked")
+        N node = (N)this;
+        while (!node.right.isLeaf()) {
+            node = node.right;
+        }
+        return node;
+    }
+    /** Returns the node immediately before this in the tree that contains this node, if any. */
+    public N predecessor() {
+        if (!left.isLeaf()) {
+            N node;
+            for (node = left; !node.right.isLeaf(); node = node.right);
+            return node;
+        } else if (parent == null) {
+            return null;
+        } else {
+            @SuppressWarnings("unchecked")
+            N node = (N)this;
+            while (node.parent != null && node.parent.left == node) {
+                node = node.parent;
+            }
+            return node.parent;
+        }
+    }
+    /** Returns the node immediately after this in the tree that contains this node, if any. */
+    public N successor() {
+        if (!right.isLeaf()) {
+            N node;
+            for (node = right; !node.left.isLeaf(); node = node.left);
+            return node;
+        } else if (parent == null) {
+            return null;
+        } else {
+            @SuppressWarnings("unchecked")
+            N node = (N)this;
+            while (node.parent != null && node.parent.right == node) {
+                node = node.parent;
+            }
+            return node.parent;
+        }
+    }
+    /**
+     * Performs a left rotation about this node. This method assumes that !isLeaf() && !right.isLeaf(). It calls
+     * augment() on this node and on its resulting parent. However, it does not call augment() on any of the resulting
+     * parent's ancestors, because that is normally the responsibility of the caller.
+     * @return The return value from calling augment() on the resulting parent.
+     */
+    public boolean rotateLeft() {
+        if (isLeaf() || right.isLeaf()) {
+            throw new IllegalArgumentException("The node or its right child is a leaf");
+        }
+        N newParent = right;
+        right = newParent.left;
+        @SuppressWarnings("unchecked")
+        N nThis = (N)this;
+        if (!right.isLeaf()) {
+            right.parent = nThis;
+        }
+        newParent.parent = parent;
+        parent = newParent;
+        newParent.left = nThis;
+        if (newParent.parent != null) {
+            if (newParent.parent.left == this) {
+                newParent.parent.left = newParent;
+            } else {
+                newParent.parent.right = newParent;
+            }
+        }
+        augment();
+        return newParent.augment();
+    }
+    /**
+     * Performs a right rotation about this node. This method assumes that !isLeaf() && !left.isLeaf(). It calls
+     * augment() on this node and on its resulting parent. However, it does not call augment() on any of the resulting
+     * parent's ancestors, because that is normally the responsibility of the caller.
+     * @return The return value from calling augment() on the resulting parent.
+     */
+    public boolean rotateRight() {
+        if (isLeaf() || left.isLeaf()) {
+            throw new IllegalArgumentException("The node or its left child is a leaf");
+        }
+        N newParent = left;
+        left = newParent.right;
+        @SuppressWarnings("unchecked")
+        N nThis = (N)this;
+        if (!left.isLeaf()) {
+            left.parent = nThis;
+        }
+        newParent.parent = parent;
+        parent = newParent;
+        newParent.right = nThis;
+        if (newParent.parent != null) {
+            if (newParent.parent.left == this) {
+                newParent.parent.left = newParent;
+            } else {
+                newParent.parent.right = newParent;
+            }
+        }
+        augment();
+        return newParent.augment();
+    }
+    /**
+     * Performs red-black insertion fixup.  To be more precise, this fixes a tree that satisfies all of the requirements
+     * of red-black trees, except that this may be a red child of a red node, and if this is the root, the root may be
+     * red.  node.isRed must initially be true.  This method assumes that this is not a leaf node.  The method performs
+     * any rotations by calling rotateLeft() and rotateRight().  This method is more efficient than fixInsertion if
+     * "augment" is false or augment() might return false.
+     * @param augment Whether to set the augmentation information for "node" and its ancestors, by calling augment().
+     */
+    public void fixInsertionWithoutGettingRoot(boolean augment) {
+        if (!isRed) {
+            throw new IllegalArgumentException("The node must be red");
+        }
+        boolean changed = augment;
+        if (augment) {
+            augment();
+        }
+        RedBlackNode<N> node = this;
+        while (node.parent != null && node.parent.isRed) {
+            N parent = node.parent;
+            N grandparent = parent.parent;
+            if (grandparent.left.isRed && grandparent.right.isRed) {
+                grandparent.left.isRed = false;
+                grandparent.right.isRed = false;
+                grandparent.isRed = true;
+                if (changed) {
+                    changed = parent.augment();
+                    if (changed) {
+                        changed = grandparent.augment();
+                    }
+                }
+                node = grandparent;
+            } else {
+                if (parent.left == node) {
+                    if (grandparent.right == parent) {
+                        parent.rotateRight();
+                        node = parent;
+                        parent = node.parent;
+                    }
+                } else if (grandparent.left == parent) {
+                    parent.rotateLeft();
+                    node = parent;
+                    parent = node.parent;
+                }
+                if (parent.left == node) {
+                    boolean grandparentChanged = grandparent.rotateRight();
+                    if (augment) {
+                        changed = grandparentChanged;
+                    }
+                } else {
+                    boolean grandparentChanged = grandparent.rotateLeft();
+                    if (augment) {
+                        changed = grandparentChanged;
+                    }
+                }
+                parent.isRed = false;
+                grandparent.isRed = true;
+                node = parent;
+                break;
+            }
+        }
+        if (node.parent == null) {
+            node.isRed = false;
+        }
+        if (changed) {
+            for (node = node.parent; node != null; node = node.parent) {
+                if (!node.augment()) {
+                    break;
+                }
+            }
+        }
+    }
+    /**
+     * Performs red-black insertion fixup.  To be more precise, this fixes a tree that satisfies all of the requirements
+     * of red-black trees, except that this may be a red child of a red node, and if this is the root, the root may be
+     * red.  node.isRed must initially be true.  This method assumes that this is not a leaf node.  The method performs
+     * any rotations by calling rotateLeft() and rotateRight().  This method is more efficient than fixInsertion() if
+     * augment() might return false.
+     */
+    public void fixInsertionWithoutGettingRoot() {
+        fixInsertionWithoutGettingRoot(true);
+    }
+    /**
+     * Performs red-black insertion fixup.  To be more precise, this fixes a tree that satisfies all of the requirements
+     * of red-black trees, except that this may be a red child of a red node, and if this is the root, the root may be
+     * red.  node.isRed must initially be true.  This method assumes that this is not a leaf node.  The method performs
+     * any rotations by calling rotateLeft() and rotateRight().
+     * @param augment Whether to set the augmentation information for "node" and its ancestors, by calling augment().
+     * @return The root of the resulting tree.
+     */
+    public N fixInsertion(boolean augment) {
+        fixInsertionWithoutGettingRoot(augment);
+        return root();
+    }
+    /**
+     * Performs red-black insertion fixup.  To be more precise, this fixes a tree that satisfies all of the requirements
+     * of red-black trees, except that this may be a red child of a red node, and if this is the root, the root may be
+     * red.  node.isRed must initially be true.  This method assumes that this is not a leaf node.  The method performs
+     * any rotations by calling rotateLeft() and rotateRight().
+     * @return The root of the resulting tree.
+     */
+    public N fixInsertion() {
+        fixInsertionWithoutGettingRoot(true);
+        return root();
+    }
+    /** Returns a Comparator that compares instances of N using their natural order, as in N.compareTo. */
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    private Comparator<N> naturalOrder() {
+        Comparator comparator = (Comparator)NATURAL_ORDER;
+        return (Comparator<N>)comparator;
+    }
+    /**
+     * Inserts the specified node into the tree rooted at this node. Assumes this is the root. We treat newNode as a
+     * solitary node that does not belong to any tree, and we ignore its initial "parent", "left", "right", and isRed
+     * fields.
+     *
+     * If it is not efficient or convenient to find the location for a node using a Comparator, then you should manually
+     * add the node to the appropriate location, color it red, and call fixInsertion().
+     *
+     * @param newNode The node to insert.
+     * @param allowDuplicates Whether to insert newNode if there is an equal node in the tree. To check whether we
+     *     inserted newNode, check whether newNode.parent is null and the return value differs from newNode.
+     * @param comparator A comparator indicating where to put the node. If this is null, we use the nodes' natural
+     *     order, as in N.compareTo. If you are passing null, then you must override the compareTo method, because the
+     *     default implementation requires the nodes to already be in the same tree.
+     * @return The root of the resulting tree.
+     */
+    public N insert(N newNode, boolean allowDuplicates, Comparator<? super N> comparator) {
+        if (parent != null) {
+            throw new IllegalArgumentException("This is not the root of a tree");
+        }
+        @SuppressWarnings("unchecked")
+        N nThis = (N)this;
+        if (isLeaf()) {
+            newNode.isRed = false;
+            newNode.left = nThis;
+            newNode.right = nThis;
+            newNode.parent = null;
+            newNode.augment();
+            return newNode;
+        }
+        if (comparator == null) {
+            comparator = naturalOrder();
+        }
+        N node = nThis;
+        int comparison;
+        while (true) {
+            comparison = comparator.compare(newNode, node);
+            if (comparison < 0) {
+                if (!node.left.isLeaf()) {
+                    node = node.left;
+                } else {
+                    newNode.left = node.left;
+                    newNode.right = node.left;
+                    node.left = newNode;
+                    newNode.parent = node;
+                    break;
+                }
+            } else if (comparison > 0 || allowDuplicates) {
+                if (!node.right.isLeaf()) {
+                    node = node.right;
+                } else {
+                    newNode.left = node.right;
+                    newNode.right = node.right;
+                    node.right = newNode;
+                    newNode.parent = node;
+                    break;
+                }
+            } else {
+                newNode.parent = null;
+                return nThis;
+            }
+        }
+        newNode.isRed = true;
+        return newNode.fixInsertion();
+    }
+    /**
+     * Moves this node to its successor's former position in the tree and vice versa, i.e. sets the "left", "right",
+     * "parent", and isRed fields of each.  This method assumes that this is not a leaf node.
+     * @return The node with which we swapped.
+     */
+    private N swapWithSuccessor() {
+        N replacement = successor();
+        boolean oldReplacementIsRed = replacement.isRed;
+        N oldReplacementLeft = replacement.left;
+        N oldReplacementRight = replacement.right;
+        N oldReplacementParent = replacement.parent;
+        replacement.isRed = isRed;
+        replacement.left = left;
+        replacement.right = right;
+        replacement.parent = parent;
+        if (parent != null) {
+            if (parent.left == this) {
+                parent.left = replacement;
+            } else {
+                parent.right = replacement;
+            }
+        }
+        @SuppressWarnings("unchecked")
+        N nThis = (N)this;
+        isRed = oldReplacementIsRed;
+        left = oldReplacementLeft;
+        right = oldReplacementRight;
+        if (oldReplacementParent == this) {
+            parent = replacement;
+            parent.right = nThis;
+        } else {
+            parent = oldReplacementParent;
+            parent.left = nThis;
+        }
+        replacement.right.parent = replacement;
+        if (!replacement.left.isLeaf()) {
+            replacement.left.parent = replacement;
+        }
+        if (!right.isLeaf()) {
+            right.parent = nThis;
+        }
+        return replacement;
+    }
+    /**
+     * Performs red-black deletion fixup.  To be more precise, this fixes a tree that satisfies all of the requirements
+     * of red-black trees, except that all paths from the root to a leaf that pass through the sibling of this node have
+     * one fewer black node than all other root-to-leaf paths.  This method assumes that this is not a leaf node.
+     */
+    private void fixSiblingDeletion() {
+        RedBlackNode<N> sibling = this;
+        boolean changed = true;
+        boolean haveAugmentedParent = false;
+        boolean haveAugmentedGrandparent = false;
+        while (true) {
+            N parent = sibling.parent;
+            if (sibling.isRed) {
+                parent.isRed = true;
+                sibling.isRed = false;
+                if (parent.left == sibling) {
+                    changed = parent.rotateRight();
+                    sibling = parent.left;
+                } else {
+                    changed = parent.rotateLeft();
+                    sibling = parent.right;
+                }
+                haveAugmentedParent = true;
+                haveAugmentedGrandparent = true;
+            } else if (!sibling.left.isRed && !sibling.right.isRed) {
+                sibling.isRed = true;
+                if (parent.isRed) {
+                    parent.isRed = false;
+                    break;
+                } else {
+                    if (changed && !haveAugmentedParent) {
+                        changed = parent.augment();
+                    }
+                    N grandparent = parent.parent;
+                    if (grandparent == null) {
+                        break;
+                    } else if (grandparent.left == parent) {
+                        sibling = grandparent.right;
+                    } else {
+                        sibling = grandparent.left;
+                    }
+                    haveAugmentedParent = haveAugmentedGrandparent;
+                    haveAugmentedGrandparent = false;
+                }
+            } else {
+                if (sibling == parent.left) {
+                    if (!sibling.left.isRed) {
+                        sibling.rotateLeft();
+                        sibling = sibling.parent;
+                    }
+                } else if (!sibling.right.isRed) {
+                    sibling.rotateRight();
+                    sibling = sibling.parent;
+                }
+                sibling.isRed = parent.isRed;
+                parent.isRed = false;
+                if (sibling == parent.left) {
+                    sibling.left.isRed = false;
+                    changed = parent.rotateRight();
+                } else {
+                    sibling.right.isRed = false;
+                    changed = parent.rotateLeft();
+                }
+                haveAugmentedParent = haveAugmentedGrandparent;
+                haveAugmentedGrandparent = false;
+                break;
+            }
+        }
+        // Update augmentation info
+        N parent = sibling.parent;
+        if (changed && parent != null) {
+            if (!haveAugmentedParent) {
+                changed = parent.augment();
+            }
+            if (changed && parent.parent != null) {
+                parent = parent.parent;
+                if (!haveAugmentedGrandparent) {
+                    changed = parent.augment();
+                }
+                if (changed) {
+                    for (parent = parent.parent; parent != null; parent = parent.parent) {
+                        if (!parent.augment()) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Removes this node from the tree that contains it.  The effect of this method on the fields of this node is
+     * unspecified.  This method assumes that this is not a leaf node.  This method is more efficient than remove() if
+     * augment() might return false.
+     *
+     * If the node has two children, we begin by moving the node's successor to its former position, by changing the
+     * successor's "left", "right", "parent", and isRed fields.
+     */
+    public void removeWithoutGettingRoot() {
+        if (isLeaf()) {
+            throw new IllegalArgumentException("Attempted to remove a leaf node");
+        }
+        N replacement;
+        if (left.isLeaf() || right.isLeaf()) {
+            replacement = null;
+        } else {
+            replacement = swapWithSuccessor();
+        }
+        N child;
+        if (!left.isLeaf()) {
+            child = left;
+        } else if (!right.isLeaf()) {
+            child = right;
+        } else {
+            child = null;
+        }
+        if (child != null) {
+            // Replace this node with its child
+            child.parent = parent;
+            if (parent != null) {
+                if (parent.left == this) {
+                    parent.left = child;
+                } else {
+                    parent.right = child;
+                }
+            }
+            child.isRed = false;
+            if (child.parent != null) {
+                N parent;
+                for (parent = child.parent; parent != null; parent = parent.parent) {
+                    if (!parent.augment()) {
+                        break;
+                    }
+                }
+            }
+        } else if (parent != null) {
+            // Replace this node with a leaf node
+            N leaf = left;
+            N parent = this.parent;
+            N sibling;
+            if (parent.left == this) {
+                parent.left = leaf;
+                sibling = parent.right;
+            } else {
+                parent.right = leaf;
+                sibling = parent.left;
+            }
+            if (!isRed) {
+                RedBlackNode<N> siblingNode = sibling;
+                siblingNode.fixSiblingDeletion();
+            } else {
+                while (parent != null) {
+                    if (!parent.augment()) {
+                        break;
+                    }
+                    parent = parent.parent;
+                }
+            }
+        }
+        if (replacement != null) {
+            replacement.augment();
+            for (N parent = replacement.parent; parent != null; parent = parent.parent) {
+                if (!parent.augment()) {
+                    break;
+                }
+            }
+        }
+        // Clear any previously existing links, so that we're more likely to encounter an exception if we attempt to
+        // access the removed node
+        parent = null;
+        left = null;
+        right = null;
+        isRed = true;
+    }
+    /**
+     * Removes this node from the tree that contains it.  The effect of this method on the fields of this node is
+     * unspecified.  This method assumes that this is not a leaf node.
+     *
+     * If the node has two children, we begin by moving the node's successor to its former position, by changing the
+     * successor's "left", "right", "parent", and isRed fields.
+     *
+     * @return The root of the resulting tree.
+     */
+    public N remove() {
+        if (isLeaf()) {
+            throw new IllegalArgumentException("Attempted to remove a leaf node");
+        }
+        // Find an arbitrary non-leaf node in the tree other than this node
+        N node;
+        if (parent != null) {
+            node = parent;
+        } else if (!left.isLeaf()) {
+            node = left;
+        } else if (!right.isLeaf()) {
+            node = right;
+        } else {
+            return left;
+        }
+        removeWithoutGettingRoot();
+        return node.root();
+    }
+    /**
+     * Returns the root of a perfectly height-balanced subtree containing the next "size" (non-leaf) nodes from
+     * "iterator", in iteration order.  This method is responsible for setting the "left", "right", "parent", and isRed
+     * fields of the nodes, and calling augment() as appropriate.  It ignores the initial values of the "left", "right",
+     * "parent", and isRed fields.
+     * @param iterator The nodes.
+     * @param size The number of nodes.
+     * @param height The "height" of the subtree's root node above the deepest leaf in the tree that contains it.  Since
+     *     insertion fixup is slow if there are too many red nodes and deleteion fixup is slow if there are too few red
+     *     nodes, we compromise and have red nodes at every fourth level.  We color a node red iff its "height" is equal
+     *     to 1 mod 4.
+     * @param leaf The leaf node.
+     * @return The root of the subtree.
+     */
+    private static <N extends RedBlackNode<N>> N createTree(
+            Iterator<? extends N> iterator, int size, int height, N leaf) {
+        if (size == 0) {
+            return leaf;
+        } else {
+            N left = createTree(iterator, (size - 1) / 2, height - 1, leaf);
+            N node = iterator.next();
+            N right = createTree(iterator, size / 2, height - 1, leaf);
+            node.isRed = height % 4 == 1;
+            node.left = left;
+            node.right = right;
+            if (!left.isLeaf()) {
+                left.parent = node;
+            }
+            if (!right.isLeaf()) {
+                right.parent = node;
+            }
+            node.augment();
+            return node;
+        }
+    }
+    /**
+     * Returns the root of a perfectly height-balanced tree containing the specified nodes, in iteration order. This
+     * method is responsible for setting the "left", "right", "parent", and isRed fields of the nodes (excluding
+     * "leaf"), and calling augment() as appropriate. It ignores the initial values of the "left", "right", "parent",
+     * and isRed fields.
+     * @param nodes The nodes.
+     * @param leaf The leaf node.
+     * @return The root of the tree.
+     */
+    public static <N extends RedBlackNode<N>> N createTree(Collection<? extends N> nodes, N leaf) {
+        int size = nodes.size();
+        if (size == 0) {
+            return leaf;
+        }
+        int height = 0;
+        for (int subtreeSize = size; subtreeSize > 0; subtreeSize /= 2) {
+            height++;
+        }
+        N node = createTree(nodes.iterator(), size, height, leaf);
+        node.parent = null;
+        node.isRed = false;
+        return node;
+    }
+    /**
+     * Concatenates to the end of the tree rooted at this node.  To be precise, given that all of the nodes in this
+     * precede the node "pivot", which precedes all of the nodes in "last", this returns the root of a tree containing
+     * all of these nodes.  This method destroys the trees rooted at "this" and "last".  We treat "pivot" as a solitary
+     * node that does not belong to any tree, and we ignore its initial "parent", "left", "right", and isRed fields.
+     * This method assumes that this node and "last" are the roots of their respective trees.
+     *
+     * This method takes O(log N) time.  It is more efficient than inserting "pivot" and then calling concatenate(last).
+     * It is considerably more efficient than inserting "pivot" and all of the nodes in "last".
+     */
+    public N concatenate(N last, N pivot) {
+        // If the black height of "first", where first = this, is less than or equal to that of "last", starting at the
+        // root of "last", we keep going left until we reach a black node whose black height is equal to that of
+        // "first".  Then, we make "pivot" the parent of that node and of "first", coloring it red, and perform
+        // insertion fixup on the pivot.  If the black height of "first" is greater than that of "last", we do the
+        // mirror image of the above.
+        if (parent != null) {
+            throw new IllegalArgumentException("This is not the root of a tree");
+        }
+        if (last.parent != null) {
+            throw new IllegalArgumentException("\"last\" is not the root of a tree");
+        }
+        // Compute the black height of the trees
+        int firstBlackHeight = 0;
+        @SuppressWarnings("unchecked")
+        N first = (N)this;
+        for (N node = first; node != null; node = node.right) {
+            if (!node.isRed) {
+                firstBlackHeight++;
+            }
+        }
+        int lastBlackHeight = 0;
+        for (N node = last; node != null; node = node.right) {
+            if (!node.isRed) {
+                lastBlackHeight++;
+            }
+        }
+        // Identify the children and parent of pivot
+        N firstChild = first;
+        N lastChild = last;
+        N parent;
+        if (firstBlackHeight <= lastBlackHeight) {
+            parent = null;
+            int blackHeight = lastBlackHeight;
+            while (blackHeight > firstBlackHeight) {
+                if (!lastChild.isRed) {
+                    blackHeight--;
+                }
+                parent = lastChild;
+                lastChild = lastChild.left;
+            }
+            if (lastChild.isRed) {
+                parent = lastChild;
+                lastChild = lastChild.left;
+            }
+        } else {
+            parent = null;
+            int blackHeight = firstBlackHeight;
+            while (blackHeight > lastBlackHeight) {
+                if (!firstChild.isRed) {
+                    blackHeight--;
+                }
+                parent = firstChild;
+                firstChild = firstChild.right;
+            }
+            if (firstChild.isRed) {
+                parent = firstChild;
+                firstChild = firstChild.right;
+            }
+        }
+        // Add "pivot" to the tree
+        pivot.isRed = true;
+        pivot.parent = parent;
+        if (parent != null) {
+            if (firstBlackHeight < lastBlackHeight) {
+                parent.left = pivot;
+            } else {
+                parent.right = pivot;
+            }
+        }
+        pivot.left = firstChild;
+        if (!firstChild.isLeaf()) {
+            firstChild.parent = pivot;
+        }
+        pivot.right = lastChild;
+        if (!lastChild.isLeaf()) {
+            lastChild.parent = pivot;
+        }
+        // Perform insertion fixup
+        return pivot.fixInsertion();
+    }
+    /**
+     * Concatenates the tree rooted at "last" to the end of the tree rooted at this node.  To be precise, given that all
+     * of the nodes in this precede all of the nodes in "last", this returns the root of a tree containing all of these
+     * nodes.  This method destroys the trees rooted at "this" and "last".  It assumes that this node and "last" are the
+     * roots of their respective trees.  This method takes O(log N) time.  It is considerably more efficient than
+     * inserting all of the nodes in "last".
+     */
+    public N concatenate(N last) {
+        if (parent != null || last.parent != null) {
+            throw new IllegalArgumentException("The node is not the root of a tree");
+        }
+        if (isLeaf()) {
+            return last;
+        } else if (last.isLeaf()) {
+            @SuppressWarnings("unchecked")
+            N nThis = (N)this;
+            return nThis;
+        } else {
+            N node = last.min();
+            last = node.remove();
+            return concatenate(last, node);
+        }
+    }
+    /**
+     * Splits the tree rooted at this node into two trees, so that the first element of the return value is the root of
+     * a tree consisting of the nodes that were before the specified node, and the second element of the return value is
+     * the root of a tree consisting of the nodes that were equal to or after the specified node. This method is
+     * destructive, meaning it does not preserve the original tree. It assumes that this node is the root and is in the
+     * same tree as splitNode. It takes O(log N) time. It is considerably more efficient than removing all of the
+     * nodes at or after splitNode and then creating a new tree from those nodes.
+     * @param The node at which to split the tree.
+     * @return An array consisting of the resulting trees.
+     */
+    public N[] split(N splitNode) {
+        // To split the tree, we accumulate a pre-split tree and a post-split tree.  We walk down the tree toward the
+        // position where we are splitting.  Whenever we go left, we concatenate the right subtree with the post-split
+        // tree, and whenever we go right, we concatenate the pre-split tree with the left subtree.  We use the
+        // concatenation algorithm described in concatenate(Object, Object).  For the pivot, we use the last node where
+        // we went left in the case of a left move, and the last node where we went right in the case of a right move.
+        //
+        // The method uses the following variables:
+        //
+        // node: The current node in our walk down the tree.
+        // first: A node on the right spine of the pre-split tree.  At the beginning of each iteration, it is the black
+        //     node with the same black height as "node".  If the pre-split tree is empty, this is null instead.
+        // firstParent: The parent of "first".  If the pre-split tree is empty, this is null.  Otherwise, this is the
+        //     same as first.parent, unless first.isLeaf().
+        // firstPivot: The node where we last went right, i.e. the next node to use as a pivot when concatenating with
+        //     the pre-split tree.
+        // advanceFirst: Whether to set "first" to be its next black descendant at the end of the loop.
+        // last, lastParent, lastPivot, advanceLast: Analogous to "first", firstParent, firstPivot, and advanceFirst,
+        //     but for the post-split tree.
+        if (parent != null) {
+            throw new IllegalArgumentException("This is not the root of a tree");
+        }
+        if (isLeaf() || splitNode.isLeaf()) {
+            throw new IllegalArgumentException("The root or the split node is a leaf");
+        }
+        // Create an array containing the path from the root to splitNode
+        int depth = 1;
+        N parent;
+        for (parent = splitNode; parent.parent != null; parent = parent.parent) {
+            depth++;
+        }
+        if (parent != this) {
+            throw new IllegalArgumentException("The split node does not belong to this tree");
+        }
+        RedBlackNode<?>[] path = new RedBlackNode<?>[depth];
+        for (parent = splitNode; parent != null; parent = parent.parent) {
+            depth--;
+            path[depth] = parent;
+        }
+        @SuppressWarnings("unchecked")
+        N node = (N)this;
+        N first = null;
+        N firstParent = null;
+        N last = null;
+        N lastParent = null;
+        N firstPivot = null;
+        N lastPivot = null;
+        while (!node.isLeaf()) {
+            boolean advanceFirst = !node.isRed && firstPivot != null;
+            boolean advanceLast = !node.isRed && lastPivot != null;
+            if ((depth + 1 < path.length && path[depth + 1] == node.left) || depth + 1 == path.length) {
+                // Left move
+                if (lastPivot == null) {
+                    // The post-split tree is empty
+                    last = node.right;
+                    last.parent = null;
+                    if (last.isRed) {
+                        last.isRed = false;
+                        lastParent = last;
+                        last = last.left;
+                    }
+                } else {
+                    // Concatenate node.right and the post-split tree
+                    if (node.right.isRed) {
+                        node.right.isRed = false;
+                    } else if (!node.isRed) {
+                        lastParent = last;
+                        last = last.left;
+                        if (last.isRed) {
+                            lastParent = last;
+                            last = last.left;
+                        }
+                        advanceLast = false;
+                    }
+                    lastPivot.isRed = true;
+                    lastPivot.parent = lastParent;
+                    if (lastParent != null) {
+                        lastParent.left = lastPivot;
+                    }
+                    lastPivot.left = node.right;
+                    if (!lastPivot.left.isLeaf()) {
+                        lastPivot.left.parent = lastPivot;
+                    }
+                    lastPivot.right = last;
+                    if (!last.isLeaf()) {
+                        last.parent = lastPivot;
+                    }
+                    last = lastPivot.left;
+                    lastParent = lastPivot;
+                    lastPivot.fixInsertionWithoutGettingRoot(false);
+                }
+                lastPivot = node;
+                node = node.left;
+            } else {
+                // Right move
+                if (firstPivot == null) {
+                    // The pre-split tree is empty
+                    first = node.left;
+                    first.parent = null;
+                    if (first.isRed) {
+                        first.isRed = false;
+                        firstParent = first;
+                        first = first.right;
+                    }
+                } else {
+                    // Concatenate the post-split tree and node.left
+                    if (node.left.isRed) {
+                        node.left.isRed = false;
+                    } else if (!node.isRed) {
+                        firstParent = first;
+                        first = first.right;
+                        if (first.isRed) {
+                            firstParent = first;
+                            first = first.right;
+                        }
+                        advanceFirst = false;
+                    }
+                    firstPivot.isRed = true;
+                    firstPivot.parent = firstParent;
+                    if (firstParent != null) {
+                        firstParent.right = firstPivot;
+                    }
+                    firstPivot.right = node.left;
+                    if (!firstPivot.right.isLeaf()) {
+                        firstPivot.right.parent = firstPivot;
+                    }
+                    firstPivot.left = first;
+                    if (!first.isLeaf()) {
+                        first.parent = firstPivot;
+                    }
+                    first = firstPivot.right;
+                    firstParent = firstPivot;
+                    firstPivot.fixInsertionWithoutGettingRoot(false);
+                }
+                firstPivot = node;
+                node = node.right;
+            }
+            depth++;
+            // Update "first" and "last" to be the nodes at the proper black height
+            if (advanceFirst) {
+                firstParent = first;
+                first = first.right;
+                if (first.isRed) {
+                    firstParent = first;
+                    first = first.right;
+                }
+            }
+            if (advanceLast) {
+                lastParent = last;
+                last = last.left;
+                if (last.isRed) {
+                    lastParent = last;
+                    last = last.left;
+                }
+            }
+        }
+        // Add firstPivot to the pre-split tree
+        N leaf = node;
+        if (first == null) {
+            first = leaf;
+        } else {
+            firstPivot.isRed = true;
+            firstPivot.parent = firstParent;
+            if (firstParent != null) {
+                firstParent.right = firstPivot;
+            }
+            firstPivot.left = leaf;
+            firstPivot.right = leaf;
+            firstPivot.fixInsertionWithoutGettingRoot(false);
+            for (first = firstPivot; first.parent != null; first = first.parent) {
+                first.augment();
+            }
+            first.augment();
+        }
+        // Add lastPivot to the post-split tree
+        lastPivot.isRed = true;
+        lastPivot.parent = lastParent;
+        if (lastParent != null) {
+            lastParent.left = lastPivot;
+        }
+        lastPivot.left = leaf;
+        lastPivot.right = leaf;
+        lastPivot.fixInsertionWithoutGettingRoot(false);
+        for (last = lastPivot; last.parent != null; last = last.parent) {
+            last.augment();
+        }
+        last.augment();
+        @SuppressWarnings("unchecked")
+        N[] result = (N[])Array.newInstance(getClass(), 2);
+        result[0] = first;
+        result[1] = last;
+        return result;
+    }
+    /**
+     * Returns the lowest common ancestor of this node and "other" - the node that is an ancestor of both and is not the
+     * parent of a node that is an ancestor of both. Assumes that this is in the same tree as "other". Assumes that
+     * neither "this" nor "other" is a leaf node. This method may return "this" or "other".
+     *
+     * Note that while it is possible to compute the lowest common ancestor in O(P) time, where P is the length of the
+     * path from this node to "other", the "lca" method is not guaranteed to take O(P) time. If your application
+     * requires this, then you should write your own lowest common ancestor method.
+     */
+    public N lca(N other) {
+        if (isLeaf() || other.isLeaf()) {
+            throw new IllegalArgumentException("One of the nodes is a leaf node");
+        }
+        // Compute the depth of each node
+        int depth = 0;
+        for (N parent = this.parent; parent != null; parent = parent.parent) {
+            depth++;
+        }
+        int otherDepth = 0;
+        for (N parent = other.parent; parent != null; parent = parent.parent) {
+            otherDepth++;
+        }
+        // Go up to nodes of the same depth
+        @SuppressWarnings("unchecked")
+        N parent = (N)this;
+        N otherParent = other;
+        if (depth <= otherDepth) {
+            for (int i = otherDepth; i > depth; i--) {
+                otherParent = otherParent.parent;
+            }
+        } else {
+            for (int i = depth; i > otherDepth; i--) {
+                parent = parent.parent;
+            }
+        }
+        // Find the LCA
+        while (parent != otherParent) {
+            parent = parent.parent;
+            otherParent = otherParent.parent;
+        }
+        if (parent != null) {
+            return parent;
+        } else {
+            throw new IllegalArgumentException("The nodes do not belong to the same tree");
+        }
+    }
+    /**
+     * Returns an integer comparing the position of this node in the tree that contains it with that of "other". Returns
+     * a negative number if this is earlier, a positive number if this is later, and 0 if this is at the same position.
+     * Assumes that this is in the same tree as "other". Assumes that neither "this" nor "other" is a leaf node.
+     *
+     * The base class's implementation takes O(log N) time. If a RedBlackNode subclass stores a value used to order the
+     * nodes, then it could override compareTo to compare the nodes' values, which would take O(1) time.
+     *
+     * Note that while it is possible to compare the positions of two nodes in O(P) time, where P is the length of the
+     * path from this node to "other", the default implementation of compareTo is not guaranteed to take O(P) time. If
+     * your application requires this, then you should write your own comparison method.
+     */
+    @Override
+    public int compareTo(N other) {
+        if (isLeaf() || other.isLeaf()) {
+            throw new IllegalArgumentException("One of the nodes is a leaf node");
+        }
+        // The algorithm operates as follows: compare the depth of this node to that of "other".  If the depth of
+        // "other" is greater, keep moving up from "other" until we find the ancestor at the same depth.  Then, keep
+        // moving up from "this" and from that node until we reach the lowest common ancestor.  The node that arrived
+        // from the left child of the common ancestor is earlier.  The algorithm is analogous if the depth of "other" is
+        // not greater.
+        if (this == other) {
+            return 0;
+        }
+        // Compute the depth of each node
+        int depth = 0;
+        RedBlackNode<N> parent;
+        for (parent = this; parent.parent != null; parent = parent.parent) {
+            depth++;
+        }
+        int otherDepth = 0;
+        N otherParent;
+        for (otherParent = other; otherParent.parent != null; otherParent = otherParent.parent) {
+            otherDepth++;
+        }
+        // Go up to nodes of the same depth
+        if (depth < otherDepth) {
+            otherParent = other;
+            for (int i = otherDepth - 1; i > depth; i--) {
+                otherParent = otherParent.parent;
+            }
+            if (otherParent.parent != this) {
+                otherParent = otherParent.parent;
+            } else if (left == otherParent) {
+                return 1;
+            } else {
+                return -1;
+            }
+            parent = this;
+        } else if (depth > otherDepth) {
+            parent = this;
+            for (int i = depth - 1; i > otherDepth; i--) {
+                parent = parent.parent;
+            }
+            if (parent.parent != other) {
+                parent = parent.parent;
+            } else if (other.left == parent) {
+                return -1;
+            } else {
+                return 1;
+            }
+            otherParent = other;
+        } else {
+            parent = this;
+            otherParent = other;
+        }
+        // Keep going up until we reach the lowest common ancestor
+        while (parent.parent != otherParent.parent) {
+            parent = parent.parent;
+            otherParent = otherParent.parent;
+        }
+        if (parent.parent == null) {
+            throw new IllegalArgumentException("The nodes do not belong to the same tree");
+        }
+        if (parent.parent.left == parent) {
+            return -1;
+        } else {
+            return 1;
+        }
+    }
+    /** Throws a RuntimeException if the RedBlackNode fields of this are not correct for a leaf node. */
+    private void assertIsValidLeaf() {
+        if (left != null || right != null || parent != null || isRed) {
+            throw new RuntimeException("A leaf node's \"left\", \"right\", \"parent\", or isRed field is incorrect");
+        }
+    }
+    /**
+     * Throws a RuntimeException if the subtree rooted at this node does not satisfy the red-black properties, excluding
+     * the requirement that the root be black, or it contains a repeated node other than a leaf node.
+     * @param blackHeight The required number of black nodes in each path from this to a leaf node, including this and
+     *     the leaf node.
+     * @param visited The nodes we have reached thus far, other than leaf nodes. This method adds the non-leaf nodes in
+     *     the subtree rooted at this node to "visited".
+     */
+    private void assertSubtreeIsValidRedBlack(int blackHeight, Set<Reference<N>> visited) {
+        @SuppressWarnings("unchecked")
+        N nThis = (N)this;
+        if (left == null || right == null) {
+            assertIsValidLeaf();
+            if (blackHeight != 1) {
+                throw new RuntimeException("Not all root-to-leaf paths have the same number of black nodes");
+            }
+            return;
+        } else if (!visited.add(new Reference<N>(nThis))) {
+            throw new RuntimeException("The tree contains a repeated non-leaf node");
+        } else {
+            int childBlackHeight;
+            if (isRed) {
+                if ((!left.isLeaf() && left.isRed) || (!right.isLeaf() && right.isRed)) {
+                    throw new RuntimeException("A red node has a red child");
+                }
+                childBlackHeight = blackHeight;
+            } else if (blackHeight == 0) {
+                throw new RuntimeException("Not all root-to-leaf paths have the same number of black nodes");
+            } else {
+                childBlackHeight = blackHeight - 1;
+            }
+            if (!left.isLeaf() && left.parent != this) {
+                throw new RuntimeException("left.parent != this");
+            }
+            if (!right.isLeaf() && right.parent != this) {
+                throw new RuntimeException("right.parent != this");
+            }
+            RedBlackNode<N> leftNode = left;
+            RedBlackNode<N> rightNode = right;
+            leftNode.assertSubtreeIsValidRedBlack(childBlackHeight, visited);
+            rightNode.assertSubtreeIsValidRedBlack(childBlackHeight, visited);
+        }
+    }
+    /** Calls assertNodeIsValid() on every node in the subtree rooted at this node. */
+    private void assertNodesAreValid() {
+        assertNodeIsValid();
+        if (left != null) {
+            RedBlackNode<N> leftNode = left;
+            RedBlackNode<N> rightNode = right;
+            leftNode.assertNodesAreValid();
+            rightNode.assertNodesAreValid();
+        }
+    }
+    /**
+     * Throws a RuntimeException if the subtree rooted at this node is not a valid red-black tree, e.g. if a red node
+     * has a red child or it contains a non-leaf node "node" for which node.left.parent != node. (If parent != null,
+     * it's okay if isRed is true.) This method is useful for debugging. See also assertSubtreeIsValid().
+     */
+    public void assertSubtreeIsValidRedBlack() {
+        if (isLeaf()) {
+            assertIsValidLeaf();
+        } else {
+            if (parent == null && isRed) {
+                throw new RuntimeException("The root is red");
+            }
+            // Compute the black height of the tree
+            Set<Reference<N>> nodes = new HashSet<Reference<N>>();
+            int blackHeight = 0;
+            @SuppressWarnings("unchecked")
+            N node = (N)this;
+            while (node != null) {
+                if (!nodes.add(new Reference<N>(node))) {
+                    throw new RuntimeException("The tree contains a repeated non-leaf node");
+                }
+                if (!node.isRed) {
+                    blackHeight++;
+                }
+                node = node.left;
+            }
+            assertSubtreeIsValidRedBlack(blackHeight, new HashSet<Reference<N>>());
+        }
+    }
+    /**
+     * Throws a RuntimeException if we detect a problem with the subtree rooted at this node, such as a red child of a
+     * red node or a non-leaf descendant "node" for which node.left.parent != node.  This method is useful for
+     * debugging.  RedBlackNode subclasses may want to override assertSubtreeIsValid() to call assertOrderIsValid.
+     */
+    public void assertSubtreeIsValid() {
+        assertSubtreeIsValidRedBlack();
+        assertNodesAreValid();
+    }
+    /**
+     * Throws a RuntimeException if the nodes in the subtree rooted at this node are not in the specified order or they
+     * do not lie in the specified range.  Assumes that the subtree rooted at this node is a valid binary tree, i.e. it
+     * has no repeated nodes other than leaf nodes.
+     * @param comparator A comparator indicating how the nodes should be ordered.
+     * @param start The lower limit for nodes in the subtree, if any.
+     * @param end The upper limit for nodes in the subtree, if any.
+     */
+    private void assertOrderIsValid(Comparator<? super N> comparator, N start, N end) {
+        if (!isLeaf()) {
+            @SuppressWarnings("unchecked")
+            N nThis = (N)this;
+            if (start != null && comparator.compare(nThis, start) < 0) {
+                throw new RuntimeException("The nodes are not ordered correctly");
+            }
+            if (end != null && comparator.compare(nThis, end) > 0) {
+                throw new RuntimeException("The nodes are not ordered correctly");
+            }
+            RedBlackNode<N> leftNode = left;
+            RedBlackNode<N> rightNode = right;
+            leftNode.assertOrderIsValid(comparator, start, nThis);
+            rightNode.assertOrderIsValid(comparator, nThis, end);
+        }
+    }
+    /**
+     * Throws a RuntimeException if the nodes in the subtree rooted at this node are not in the specified order.
+     * Assumes that this is a valid binary tree, i.e. there are no repeated nodes other than leaf nodes.  This method is
+     * useful for debugging.  RedBlackNode subclasses may want to override assertSubtreeIsValid() to call
+     * assertOrderIsValid.
+     * @param comparator A comparator indicating how the nodes should be ordered.  If this is null, we use the nodes'
+     *     natural order, as in N.compareTo.
+     */
+    public void assertOrderIsValid(Comparator<? super N> comparator) {
+        if (comparator == null) {
+            comparator = naturalOrder();
+        }
+        assertOrderIsValid(comparator, null, null);
+    }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Reference.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Reference.java
new file mode 100644
index 00000000..a25c167d
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Reference.java
@@ -0,0 +1,51 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 btrekkie
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval;
+/**
+ * Wraps a value using reference equality.  In other words, two references are equal only if their values are the same
+ * object instance, as in ==.
+ * @param <T> The type of value.
+ */
+class Reference<T> {
+    /** The value this wraps. */
+    private final T value;
+    public Reference(T value) {
+        this.value = value;
+    }
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Reference)) {
+            return false;
+        }
+        Reference<?> reference = (Reference<?>)obj;
+        return value == reference.value;
+    }
+    @Override
+    public int hashCode() {
+        return System.identityHashCode(value);
+    }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/IntervalAggregatorFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/IntervalAggregatorFactory.xtend
new file mode 100644
index 00000000..dee31f67
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/IntervalAggregatorFactory.xtend
@@ -0,0 +1,50 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.aggregators
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalAggregationMode
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalAggregationOperator
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.AggregatorType
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.BoundAggregator
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IAggregatorFactory
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+@AggregatorType(parameterTypes=#[Interval], returnTypes=#[Interval])
+abstract class IntervalAggregatorFactory implements IAggregatorFactory {
+        val IntervalAggregationMode mode
+        @FinalFieldsConstructor
+        protected new() {
+        }
+        override getAggregatorLogic(Class<?> domainClass) {
+                if (domainClass == Interval) {
+                        new BoundAggregator(new IntervalAggregationOperator(mode), Interval, Interval)
+                } else {
+                        throw new IllegalArgumentException("Unknown domain class: " + domainClass)
+                }
+        }
+}
+class intervalSum extends IntervalAggregatorFactory {
+        new() {
+                super(IntervalAggregationMode.SUM)
+        }
+}
+class intervalMin extends IntervalAggregatorFactory {
+        new() {
+                super(IntervalAggregationMode.MIN)
+        }
+}
+class intervalMax extends IntervalAggregatorFactory {
+        new() {
+                super(IntervalAggregationMode.MAX)
+        }
+}
+class intervalJoin extends IntervalAggregatorFactory {
+        new() {
+                super(IntervalAggregationMode.JOIN)
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/intervalHull.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/intervalHull.xtend
new file mode 100644
index 00000000..72605f57
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/intervalHull.xtend
@@ -0,0 +1,74 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.aggregators
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalHullAggregatorOperator
+import java.math.BigDecimal
+import java.math.BigInteger
+import java.math.MathContext
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.AggregatorType
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.BoundAggregator
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IAggregatorFactory
+@AggregatorType(parameterTypes=#[BigDecimal, BigInteger, Byte, Double, Float, Integer, Long, Short], returnTypes=#[
+        Interval, Interval, Interval, Interval, Interval, Interval, Interval, Interval])
+class intervalHull implements IAggregatorFactory {
+        override getAggregatorLogic(Class<?> domainClass) {
+                new BoundAggregator(getAggregationOperator(domainClass), domainClass, Interval)
+        }
+        private def getAggregationOperator(Class<?> domainClass) {
+                switch (domainClass) {
+                        case BigDecimal:
+                                new IntervalHullAggregatorOperator<BigDecimal>() {
+                                        override protected toBigDecimal(BigDecimal value, MathContext mc) {
+                                                value.round(mc)
+                                        }
+                                }
+                        case BigInteger:
+                                new IntervalHullAggregatorOperator<BigInteger>() {
+                                        override protected toBigDecimal(BigInteger value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        case Byte:
+                                new IntervalHullAggregatorOperator<Byte>() {
+                                        override protected toBigDecimal(Byte value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        case Double:
+                                new IntervalHullAggregatorOperator<Double>() {
+                                        override protected toBigDecimal(Double value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        case Float:
+                                new IntervalHullAggregatorOperator<Float>() {
+                                        override protected toBigDecimal(Float value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        case Integer:
+                                new IntervalHullAggregatorOperator<Integer>() {
+                                        override protected toBigDecimal(Integer value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        case Long:
+                                new IntervalHullAggregatorOperator<Long>() {
+                                        override protected toBigDecimal(Long value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        case Short:
+                                new IntervalHullAggregatorOperator<Short>() {
+                                        override protected toBigDecimal(Short value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        default:
+                                throw new IllegalArgumentException("Unknown domain class: " + domainClass)
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend
index d6a15c1a..0e0f1f02 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend
@@ -1,209 +1,150 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
-import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
-import org.eclipse.emf.ecore.EClass
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
 class GenericTypeIndexer extends TypeIndexer {
-        val PatternGenerator base;
-        
        new(PatternGenerator base) {
-                this.base = base
+                super(base)
        }
        override requiresTypeAnalysis() { false }
-        
-        public override getRequiredQueries() '''
+        override getRequiredQueries() '''
-        private pattern newELement(interpretation: PartialInterpretation, element: DefinedElement) {
+                «super.requiredQueries»
-                PartialInterpretation.newElements(interpretation,element);
+                
-        }
+                /**
-        
+                 * Direct supertypes of a type.
-        private pattern typeInterpretation(problem:LogicProblem, interpetation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) {
+                 */
-                find interpretation(problem,interpetation);
+                private pattern supertypeDirect(subtype : Type, supertype : Type) {
-                LogicProblem.types(problem,type);
+                        Type.supertypes(subtype, supertype);
-                PartialInterpretation.partialtypeinterpratation(interpetation,typeInterpretation);
+                }
-                PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type);
+                
-        }
+                /**
-        
+                 * All supertypes of a type.
-        private pattern directInstanceOf(problem:LogicProblem, interpetation:PartialInterpretation, element:DefinedElement, type:Type) {
+                 */
-                find interpretation(problem,interpetation);
+                private pattern supertypeStar(subtype: Type, supertype: Type) {
-                find mustExist(problem,interpetation,element);
+                        subtype == supertype;
-                LogicProblem.types(problem,type);
+                } or {
-                TypeDefinition.elements(type,element);
+                        find supertypeDirect+(subtype,supertype);
-        } or {
+                }
-                find mustExist(problem,interpetation,element);
+                
-                find typeInterpretation(problem,interpetation,type,typeInterpretation);
+                /// Complex type reasoning patterns ///
-                PartialComplexTypeInterpretation.elements(typeInterpretation,element);
+                //
-        }
+                // In a valid type system, for each element e there is exactly one type T where
-        
+                // 1: T(e) - but we dont know this for type declaration
-        /**
+                // 2: For the dynamic type D and another type T, where D(e) && D-->T, T(e) is true.
-         * Direct supertypes of a type.
+                // 2e: A type hierarchy is invalid, if there is a supertype T for a dynamic type D which does no contains e:
-         */
+                //     D(e) && D-->T && !T(e)
-        private pattern supertypeDirect(subtype : Type, supertype : Type) {
+                // 3: There is no T' that T'->T and T'(e)
-                Type.supertypes(subtype, supertype);
+                // 3e: A type hierarcy is invalid, if there is a type T for a dynamic type D, which contains e, but not subtype of T:
-        }
+                //    D(e) && ![T--->D] && T(e)
-        
-        /**
-         * All supertypes of a type.
-         */
-        private pattern supertypeStar(subtype: Type, supertype: Type) {
-                subtype == supertype;
-        } or {
-                find supertypeDirect+(subtype,supertype);
-        }
-        
-        /// Complex type reasoning patterns ///
-        //
-        // In a valid type system, for each element e there is exactly one type T where
-        // 1: T(e) - but we dont know this for type declaration
-        // 2: For the dynamic type D and another type T, where D(e) && D-->T, T(e) is true.
-        // 2e: A type hierarchy is invalid, if there is a supertype T for a dynamic type D which does no contains e:
-        //     D(e) && D-->T && !T(e)
-        // 3: There is no T' that T'->T and T'(e)
-        // 3e: A type hierarcy is invalid, if there is a type T for a dynamic type D, which contains e, but not subtype of T:
-        //    D(e) && ![T--->D] && T(e)
-        // 4: T is not abstract
-        // Such type T is called Dynamic type of e, while other types are called static types.
-        // 
-        // The following patterns checks the possible dynamic types for an element
-        
-        private pattern wellformedType(problem: LogicProblem, interpretation:PartialInterpretation, dynamic:Type, element:DefinedElement) {
-                // 1: T(e)
-                find directInstanceOf(problem,interpretation,element,dynamic);
-                // 2e is not true: D(e) && D-->T && !T(e)
-                neg find dynamicTypeNotSubtypeOfADefinition(problem,interpretation,element,dynamic);
-                // 3e is not true: D(e) && ![T--->D] && T(e)
-                neg find dynamicTypeIsSubtypeOfANonDefinition(problem,interpretation,element,dynamic);
-                // 4: T is not abstract
-                Type.isAbstract(dynamic,false);
-        }
-        
-        
-        private pattern isPrimitive(element: PrimitiveElement) {
-                PrimitiveElement(element);
-        }
-        
-        private pattern possibleDynamicType(problem: LogicProblem, interpretation:PartialInterpretation, dynamic:Type, element:DefinedElement)
-        // case 1: element is defined at least once
-        {
-                LogicProblem.types(problem,dynamic);
-                // select a random definition 'randomType'
-                find directInstanceOf(problem,interpretation,element,randomType);
-                // dynamic is a subtype of 'randomType'
-                find supertypeStar(dynamic,randomType);
-                // 2e is not true: D(e) && D-->T && !T(e)
-                neg find dynamicTypeNotSubtypeOfADefinition(problem,interpretation,element,dynamic);
-                // 3e is not true: D(e) && ![T--->D] && T(e)
-                neg find dynamicTypeIsSubtypeOfANonDefinition(problem,interpretation,element,dynamic);
-                // 4: T is not abstract
-                Type.isAbstract(dynamic,false);
-                // 5. element is not primitive datatype
-                neg find isPrimitive(element);
-        } or
-        // case 2: element is not defined anywhere
-        {
-                find mayExist(problem,interpretation,element);
-                // there is no definition
-                neg find directInstanceOf(problem,interpretation,element,_);
-                // 2e is not true: D(e) && D-->T && !T(e)
-                // because non of the definition contains element, the type cannot have defined supertype
-                LogicProblem.types(problem,dynamic);
-                PartialInterpretation.problem(interpretation,problem);
-                neg find typeWithDefinedSupertype(dynamic);
-                // 3e is not true: D(e) && ![T--->D] && T(e)
-                // because there is no definition, dynamic covers all definition
                // 4: T is not abstract
-                Type.isAbstract(dynamic,false);
+                // Such type T is called Dynamic type of e, while other types are called static types.
-                // 5. element is not primitive datatype
+                // 
-                neg find isPrimitive(element);
+                // The following patterns checks the possible dynamic types for an element
-        }
+                
-        
+                private pattern wellformedType(problem: LogicProblem, interpretation:PartialInterpretation, dynamic:Type, element:DefinedElement) {
-        /**
+                        // 1: T(e)
-         * supertype -------> element <------- otherSupertype
+                        find directInstanceOf(problem,interpretation,element,dynamic);
-         *     A                                     A
+                        // 2e is not true: D(e) && D-->T && !T(e)
-         *     |                                     |
+                        neg find dynamicTypeNotSubtypeOfADefinition(problem,interpretation,element,dynamic);
-         * wrongDynamic -----------------------------X
+                        // 3e is not true: D(e) && ![T--->D] && T(e)
-         */
+                        neg find dynamicTypeIsSubtypeOfANonDefinition(problem,interpretation,element,dynamic);
-        private pattern dynamicTypeNotSubtypeOfADefinition(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, wrongDynamic : Type) {
+                        // 4: T is not abstract
-                find directInstanceOf(problem,interpretation,element,supertype);
+                        Type.isAbstract(dynamic,false);
-                find directInstanceOf(problem,interpretation,element,otherSupertype);
+                }
-                find supertypeStar(wrongDynamic,supertype);
+                
-                neg find supertypeStar(wrongDynamic,otherSupertype);
+                private pattern possibleDynamicType(problem: LogicProblem, interpretation:PartialInterpretation, dynamic:Type, element:DefinedElement)
-        }
+                // case 1: element is defined at least once
-        
+                {
-        /**
+                        LogicProblem.types(problem,dynamic);
-         * supertype -------> element <---X--- otherSupertype
+                        // select a random definition 'randomType'
-         *     A                                     A
+                        find directInstanceOf(problem,interpretation,element,randomType);
-         *     |                                     |
+                        // dynamic is a subtype of 'randomType'
-         * wrongDynamic -----------------------------+
+                        find supertypeStar(dynamic,randomType);
-         */
+                        // 2e is not true: D(e) && D-->T && !T(e)
-        private pattern dynamicTypeIsSubtypeOfANonDefinition(problem: LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, wrongDynamic:Type) {
+                        neg find dynamicTypeNotSubtypeOfADefinition(problem,interpretation,element,dynamic);
-                find directInstanceOf(problem,interpretation,element,supertype);
+                        // 3e is not true: D(e) && ![T--->D] && T(e)
-                neg find elementInTypeDefinition(element,otherSupertype);
+                        neg find dynamicTypeIsSubtypeOfANonDefinition(problem,interpretation,element,dynamic);
-                TypeDefinition(otherSupertype);
+                        // 4: T is not abstract
-                find supertypeStar(wrongDynamic, supertype);
+                        Type.isAbstract(dynamic,false);
-                find supertypeStar(wrongDynamic, otherSupertype);
+                        // 5. element is not primitive datatype
-        }
+                        neg find isPrimitive(element);
-        
+                } or
-        private pattern elementInTypeDefinition(element:DefinedElement, definition:TypeDefinition) {
+                // case 2: element is not defined anywhere
-                TypeDefinition.elements(definition,element);
+                {
-        }
+                        find mayExist(problem,interpretation,element);
-        
+                        // there is no definition
-        private pattern typeWithDefinedSupertype(type:Type) {
+                        neg find directInstanceOf(problem,interpretation,element,_);
-                find supertypeStar(type,definedSupertype);
+                        // 2e is not true: D(e) && D-->T && !T(e)
-                TypeDefinition(definedSupertype);
+                        // because non of the definition contains element, the type cannot have defined supertype
-        }
+                        LogicProblem.types(problem,dynamic);
-        
+                        PartialInterpretation.problem(interpretation,problem);
-        private pattern scopeDisallowsNewElementsFromType(typeInterpretation:PartialComplexTypeInterpretation) {
+                        neg find typeWithDefinedSupertype(dynamic);
-                Scope.targetTypeInterpretation(scope,typeInterpretation);
+                        // 3e is not true: D(e) && ![T--->D] && T(e)
-                Scope.maxNewElements(scope,0);
+                        // because there is no definition, dynamic covers all definition
-        }
+                        // 4: T is not abstract
-        '''
+                        Type.isAbstract(dynamic,false);
-        
+                        // 5. element is not primitive datatype
-        public override generateInstanceOfQueries(LogicProblem problem, PartialInterpretation emptySolution,TypeAnalysisResult typeAnalysisResult) {
+                        neg find isPrimitive(element);
-                '''
+                }
-                «FOR type:problem.types»
+                
-                        «problem.generateMustInstenceOf(type)»
-                        «problem.generateMayInstanceOf(type)»
-                «ENDFOR»
-                '''
-        }
-        
-        private def patternName(Type type, Modality modality)
-                '''«modality.toString.toLowerCase»InstanceOf«base.canonizeName(type.name)»'''
-        
-        private def generateMustInstenceOf(LogicProblem problem, Type type) {
-                '''
                /**
-                 * An element must be an instance of type "«type.name»".
+                 * supertype -------> element <------- otherSupertype
+                 *     A                                     A
+                 *     |                                     |
+                 * wrongDynamic -----------------------------X
                 */
-                private pattern «patternName(type,Modality.MUST)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
+                private pattern dynamicTypeNotSubtypeOfADefinition(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, wrongDynamic : Type) {
-                        Type.name(type,"«type.name»");
+                        find directInstanceOf(problem,interpretation,element,supertype);
-                        find directInstanceOf(problem,interpretation,element,type);
+                        find directInstanceOf(problem,interpretation,element,otherSupertype);
+                        find supertypeStar(wrongDynamic,supertype);
+                        neg find supertypeStar(wrongDynamic,otherSupertype);
                }
-                '''
+                
-        }
-        
-        private def generateMayInstanceOf(LogicProblem problem, Type type) {
-                '''
                /**
-                 * An element may be an instance of type "«type.name»".
+                 * supertype -------> element <---X--- otherSupertype
+                 *     A                                     A
+                 *     |                                     |
+                 * wrongDynamic -----------------------------+
                 */
-                private pattern «patternName(type,Modality.MAY)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
+                private pattern dynamicTypeIsSubtypeOfANonDefinition(problem: LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, wrongDynamic:Type) {
-                        Type.name(type,"«type.name»");
+                        find directInstanceOf(problem,interpretation,element,supertype);
-                        find possibleDynamicType(problem,interpretation,dynamic,element);
+                        neg find elementInTypeDefinition(element,otherSupertype);
-                        find supertypeStar(dynamic,type);
+                        TypeDefinition(otherSupertype);
-                        neg find scopeDisallowsNewElementsFromType(dynamic);
+                        find supertypeStar(wrongDynamic, supertype);
+                        find supertypeStar(wrongDynamic, otherSupertype);
+                }
+                
+                private pattern elementInTypeDefinition(element:DefinedElement, definition:TypeDefinition) {
+                        TypeDefinition.elements(definition,element);
+                }
+                
+                private pattern typeWithDefinedSupertype(type:Type) {
+                        find supertypeStar(type,definedSupertype);
+                        TypeDefinition(definedSupertype);
+                }
+                
+                private pattern scopeDisallowsNewElementsFromType(typeInterpretation:PartialComplexTypeInterpretation) {
+                        Scope.targetTypeInterpretation(scope,typeInterpretation);
+                        Scope.maxNewElements(scope,0);
                }
+        '''
+        protected override generateMayInstanceOf(LogicProblem problem, Type type, TypeAnalysisResult typeAnalysisResult) {
+                '''
+                        /**
+                         * An element may be an instance of type "«type.name»".
+                         */
+                        private pattern «patternName(type,Modality.MAY)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
+                                Type.name(type,"«type.name»");
+                                find possibleDynamicType(problem,interpretation,dynamic,element);
+                                find supertypeStar(dynamic,type);
+                                neg find scopeDisallowsNewElementsFromType(dynamic);
+                        }
                '''
        }
-        
+}
-        public override referInstanceOf(Type type, Modality modality, String variableName) {
-                '''find «patternName(type,modality)»(problem,interpretation,«variableName»);'''
-        }
-        public override referInstanceOf(EClass type, Modality modality, String variableName) {
-                '''find «modality.toString.toLowerCase»InstanceOf«base.canonizeName('''«type.name» class''')»(problem,interpretation,«variableName»);'''
-        }
-}
-\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeRefinementGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeRefinementGenerator.xtend
index 2e03d6ed..52f0cbea 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeRefinementGenerator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeRefinementGenerator.xtend
@@ -11,110 +11,114 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.par
 import java.util.HashMap
 class GenericTypeRefinementGenerator extends TypeRefinementGenerator {
-        public new(PatternGenerator base) {
+        new(PatternGenerator base) {
                super(base)
        }
        override requiresTypeAnalysis() { false }
-        
-        override generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
+        override generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution,
+                TypeAnalysisResult typeAnalysisResult) {
                val containment = p.containmentHierarchies.head
                val newObjectTypes = p.types.filter(TypeDeclaration).filter[!isAbstract]
                val inverseRelations = new HashMap
-                p.annotations.filter(InverseRelationAssertion).forEach[
+                p.annotations.filter(InverseRelationAssertion).forEach [
-                        inverseRelations.put(it.inverseA,it.inverseB)
+                        inverseRelations.put(it.inverseA, it.inverseB)
-                        inverseRelations.put(it.inverseB,it.inverseA)
+                        inverseRelations.put(it.inverseB, it.inverseA)
                ]
                return '''
-                private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation)
+                        pattern «hasElementInContainmentName»(problem:LogicProblem, interpretation:PartialInterpretation)
-                «FOR type :containment.typesOrderedInHierarchy SEPARATOR "or"»{
+                        «FOR type : containment.typesOrderedInHierarchy SEPARATOR "or"»{
-                        find interpretation(problem,interpretation);
-                        «base.typeIndexer.referInstanceOf(type,Modality.MUST,"root")»
-                        find mustExist(problem, interpretation, root);
-                }«ENDFOR»
-                «FOR type:newObjectTypes»
-                        «IF(containment.typesOrderedInHierarchy.contains(type))»
-                                «FOR containmentRelation : containment.containmentRelations.filter[canBeContainedByRelation(it,type)]»
-                                        «IF inverseRelations.containsKey(containmentRelation)»
-                                                pattern «this.patternName(containmentRelation,inverseRelations.get(containmentRelation),type)»(
-                                                        problem:LogicProblem, interpretation:PartialInterpretation,
-                                                        relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation ,typeInterpretation:PartialComplexTypeInterpretation,
-                                                        container:DefinedElement)
-                                                {
-                                                        find interpretation(problem,interpretation);
-                                                        PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
-                                                        PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"«type.name»");
-                                                        PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation);
-                                                        PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»");
-                                                        PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation);
-                                                        PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"«inverseRelations.get(containmentRelation).name»");
-                                                        «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")»
-                                                        «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
-                                                        «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)»
-                                                        find mustExist(problem, interpretation, container);
-                                                        neg find mustExist(problem, interpretation, newObject);
-                                                }
-                                        «ELSE»
-                                                pattern «this.patternName(containmentRelation,null,type)»(
-                                                        problem:LogicProblem, interpretation:PartialInterpretation,
-                                                        relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation,
-                                                        container:DefinedElement)
-                                                {
-                                                        find interpretation(problem,interpretation);
-                                                        PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
-                                                        PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"«type.name»");
-                                                        PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation);
-                                                        PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»");
-                                                        «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")»
-                                                        «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
-                                                        «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)»
-                                                        find mustExist(problem, interpretation, container);
-                                                        neg find mustExist(problem, interpretation, newObject);
-                                                }
-                                        «ENDIF»
-                                «ENDFOR»
-                                pattern «patternName(null,null,type)»(
-                                        problem:LogicProblem, interpretation:PartialInterpretation,
-                                        typeInterpretation:PartialComplexTypeInterpretation)
-                                {
                                        find interpretation(problem,interpretation);
-                                        neg find hasElementInContainment(problem,interpretation);
+                                        «base.typeIndexer.referInstanceOf(type,Modality.MUST,"root")»
-                                        PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
+                                        find mustExist(problem, interpretation, root);
-                                        PartialComplexTypeInterpretation.interpretationOf.name(type,"«type.name»");
+                        }«ENDFOR»
-                                        «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
+                        «FOR type : newObjectTypes»
-                                        find mayExist(problem, interpretation, newObject);
+                                «IF(containment.typesOrderedInHierarchy.contains(type))»
-                                        neg find mustExist(problem, interpretation, newObject);
+                                        «FOR containmentRelation : containment.containmentRelations.filter[canBeContainedByRelation(it,type)]»
-                                }
+                                                «IF inverseRelations.containsKey(containmentRelation)»
-                        «ELSE»
+                                                        pattern «this.patternName(containmentRelation,inverseRelations.get(containmentRelation),type)»(
-                                pattern createObject_«this.patternName(null,null,type)»(
+                                                                problem:LogicProblem, interpretation:PartialInterpretation,
-                                        problem:LogicProblem, interpretation:PartialInterpretation,
+                                                                relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation ,typeInterpretation:PartialComplexTypeInterpretation,
-                                        typeInterpretation:PartialComplexTypeInterpretation)
+                                                                container:DefinedElement)
-                                {
+                                                        {
-                                        find interpretation(problem,interpretation);
+                                                                find interpretation(problem,interpretation);
-                                        PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
+                                                                PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
-                                        PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"«type.name»");
+                                                                PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"«type.name»");
-                                        «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
+                                                                PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation);
-                                        find mayExist(problem, interpretation, newObject);
+                                                                PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»");
-                                        neg find mustExist(problem, interpretation, newObject);
+                                                                PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation);
-                                }
+                                                                PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"«inverseRelations.get(containmentRelation).name»");
-                        «ENDIF»
+                                                                «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")»
-                «ENDFOR»
+                                                                «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
+                                                                «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)»
+                                                                find mustExist(problem, interpretation, container);
+                                                                neg find mustExist(problem, interpretation, newObject);
+                                                        }
+                                                «ELSE»
+                                                        pattern «this.patternName(containmentRelation,null,type)»(
+                                                                problem:LogicProblem, interpretation:PartialInterpretation,
+                                                                relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation,
+                                                                container:DefinedElement)
+                                                        {
+                                                                find interpretation(problem,interpretation);
+                                                                PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
+                                                                PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"«type.name»");
+                                                                PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation);
+                                                                PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»");
+                                                                «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")»
+                                                                «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
+                                                                «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)»
+                                                                find mustExist(problem, interpretation, container);
+                                                                neg find mustExist(problem, interpretation, newObject);
+                                                        }
+                                                «ENDIF»
+                                        «ENDFOR»
+                                        pattern «patternName(null,null,type)»(
+                                                problem:LogicProblem, interpretation:PartialInterpretation,
+                                                typeInterpretation:PartialComplexTypeInterpretation)
+                                        {
+                                                find interpretation(problem,interpretation);
+                                                neg find  «hasElementInContainmentName»(problem,interpretation);
+                                                PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
+                                                PartialComplexTypeInterpretation.interpretationOf.name(type,"«type.name»");
+                                                «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
+                                                find mayExist(problem, interpretation, newObject);
+                                                neg find mustExist(problem, interpretation, newObject);
+                                        }
+                                «ELSE»
+                                        pattern createObject_«this.patternName(null,null,type)»(
+                                                problem:LogicProblem, interpretation:PartialInterpretation,
+                                                typeInterpretation:PartialComplexTypeInterpretation)
+                                        {
+                                                find interpretation(problem,interpretation);
+                                                PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
+                                                PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"«type.name»");
+                                                «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
+                                                find mayExist(problem, interpretation, newObject);
+                                                neg find mustExist(problem, interpretation, newObject);
+                                        }
+                                «ENDIF»
+                        «ENDFOR»
                '''
        }
-        override generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
+        override generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution,
+                TypeAnalysisResult typeAnalysisResult) {
                return '''
-                «FOR type : p.types.filter(TypeDeclaration).filter[!it.isAbstract]»
+                        «FOR type : p.types.filter(TypeDeclaration).filter[!it.isAbstract]»
-                        pattern refineTypeTo_«base.canonizeName(type.name)»(problem:LogicProblem, interpretation:PartialInterpretation, object: DefinedElement) {
+                                pattern refineTypeTo_«base.canonizeName(type.name)»(problem:LogicProblem, interpretation:PartialInterpretation, object: DefinedElement) {
-                                find interpretation(problem,interpretation);
+                                        find interpretation(problem,interpretation);
-                                find mustExist(problem, interpretation, object);
+                                        find mustExist(problem, interpretation, object);
-                                «base.typeIndexer.referInstanceOf(type,Modality.MAY,"object")»
+                                        «base.typeIndexer.referInstanceOf(type,Modality.MAY,"object")»
-                                neg «base.typeIndexer.referInstanceOf(type,Modality.MUST,"object")»
+                                        neg «base.typeIndexer.referInstanceOf(type,Modality.MUST,"object")»
-                        }
+                                }
-                «ENDFOR»
+                        «ENDFOR»
                '''
        }
-        
-        override getRefineTypeQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
+        override getRefineTypeQueryNames(LogicProblem p, PartialInterpretation emptySolution,
+                TypeAnalysisResult typeAnalysisResult) {
                p.types.filter(TypeDeclaration).toInvertedMap['''refineTypeTo_«base.canonizeName(it.name)»''']
-        }       
+        }
-}
-\ No newline at end of file
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
index 677170b8..f3125b80 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
@@ -1,7 +1,6 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
 import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion
-import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolTypeReference
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntTypeReference
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealTypeReference
@@ -17,7 +16,11 @@ import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.Transform
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearTypeConstraintHint
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.RelationConstraints
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagatorStrategy
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import java.util.Collection
 import java.util.HashMap
 import java.util.Map
 import org.eclipse.emf.ecore.EAttribute
@@ -36,21 +39,23 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint
 }
 class PatternGenerator {
-        @Accessors(PUBLIC_GETTER) val TypeIndexer typeIndexer //= new TypeIndexer(this)
+        @Accessors(PUBLIC_GETTER) val TypeIndexer typeIndexer // = new TypeIndexer(this)
-        @Accessors(PUBLIC_GETTER) val RelationDeclarationIndexer relationDeclarationIndexer = new RelationDeclarationIndexer(this)
+        @Accessors(PUBLIC_GETTER) val RelationDeclarationIndexer relationDeclarationIndexer = new RelationDeclarationIndexer(
-        @Accessors(PUBLIC_GETTER) val RelationDefinitionIndexer relationDefinitionIndexer = new RelationDefinitionIndexer(this)
+                this)
+        @Accessors(PUBLIC_GETTER) val RelationDefinitionIndexer relationDefinitionIndexer = new RelationDefinitionIndexer(
+                this)
        @Accessors(PUBLIC_GETTER) val ContainmentIndexer containmentIndexer = new ContainmentIndexer(this)
        @Accessors(PUBLIC_GETTER) val InvalidIndexer invalidIndexer = new InvalidIndexer(this)
-        @Accessors(PUBLIC_GETTER) val UnfinishedIndexer unfinishedIndexer = new UnfinishedIndexer(this)
+        @Accessors(PUBLIC_GETTER) val UnfinishedIndexer unfinishedIndexer
        @Accessors(PUBLIC_GETTER) val TypeRefinementGenerator typeRefinementGenerator //= new RefinementGenerator(this)
        @Accessors(PUBLIC_GETTER) val RelationRefinementGenerator relationRefinementGenerator = new RelationRefinementGenerator(this)
        @Accessors(PUBLIC_GETTER) val UnitPropagationPreconditionGenerator unitPropagationPreconditionGenerator = new UnitPropagationPreconditionGenerator(this)
        
-        public new(TypeInferenceMethod typeInferenceMethod) {
+        public new(TypeInferenceMethod typeInferenceMethod, ScopePropagatorStrategy scopePropagatorStrategy) {
                if(typeInferenceMethod == TypeInferenceMethod.Generic) {
                        this.typeIndexer = new GenericTypeIndexer(this)
                        this.typeRefinementGenerator = new GenericTypeRefinementGenerator(this)
-                } else if(typeInferenceMethod == TypeInferenceMethod.PreliminaryAnalysis) {
+                } else if (typeInferenceMethod == TypeInferenceMethod.PreliminaryAnalysis) {
                        this.typeIndexer = new TypeIndexerWithPreliminaryTypeAnalysis(this)
                        this.typeRefinementGenerator = new TypeRefinementWithPreliminaryTypeAnalysis(this)
                } else {
@@ -58,110 +63,101 @@ class PatternGenerator {
                        this.typeRefinementGenerator = null
                        throw new IllegalArgumentException('''Unknown type indexing technique : «typeInferenceMethod.name»''')
                }
+                this.unfinishedIndexer = new UnfinishedIndexer(this, scopePropagatorStrategy.requiresUpperBoundIndexing)
        }
-        
-        public def requiresTypeAnalysis() {
+        def requiresTypeAnalysis() {
                typeIndexer.requiresTypeAnalysis || typeRefinementGenerator.requiresTypeAnalysis
        }
-        
-        public dispatch def referRelation(
+        dispatch def CharSequence referRelation(RelationDeclaration referred, String sourceVariable, String targetVariable,
-                RelationDeclaration referred,
+                Modality modality, Map<String, PQuery> fqn2PQuery) {
-                String sourceVariable,
+                return this.relationDeclarationIndexer.referRelation(referred, sourceVariable, targetVariable, modality)
-                String targetVariable,
-                Modality modality,
-                Map<String,PQuery> fqn2PQuery)
-        {
-                return this.relationDeclarationIndexer.referRelation(referred,sourceVariable,targetVariable,modality)
        }
-        public dispatch def referRelation(
-                RelationDefinition referred,
+        dispatch def CharSequence referRelation(RelationDefinition referred, String sourceVariable, String targetVariable,
-                String sourceVariable,
+                Modality modality, Map<String, PQuery> fqn2PQuery) {
-                String targetVariable,
+                val pattern = referred.annotations.filter(TransfomedViatraQuery).head.patternFullyQualifiedName.lookup(
-                Modality modality,
+                        fqn2PQuery)
-                Map<String,PQuery> fqn2PQuery)
+                return this.relationDefinitionIndexer.referPattern(pattern, #[sourceVariable, targetVariable], modality, true,
-        {
+                        false)
-                val pattern = referred.annotations.filter(TransfomedViatraQuery).head.patternFullyQualifiedName.lookup(fqn2PQuery)
-                return this.relationDefinitionIndexer.referPattern(pattern,#[sourceVariable,targetVariable],modality,true,false)
        }
-        
-        def public referRelationByName(EReference reference,
+        def referRelationByName(EReference reference, String sourceVariable, String targetVariable, Modality modality) {
-                String sourceVariable,
+                '''find «modality.name.toLowerCase»InRelation«canonizeName('''«reference.name» reference «reference.EContainingClass.name»''')»(problem,interpretation,«sourceVariable»,«targetVariable»);'''
-                String targetVariable,
-                Modality modality)
-        {
-                '''find «modality.name.toLowerCase»InRelation«canonizeName('''«reference.name» reference «reference.EContainingClass.name»''')
-                »(problem,interpretation,«sourceVariable»,«targetVariable»);'''
        }
-        
-        def public CharSequence referAttributeByName(EAttribute attribute,
+        def CharSequence referAttributeByName(EAttribute attribute, String sourceVariable, String targetVariable,
-                String sourceVariable,
+                Modality modality) {
-                String targetVariable,
+                '''find «modality.name.toLowerCase»InRelation«canonizeName('''«attribute.name» attribute «attribute.EContainingClass.name»''')»(problem,interpretation,«sourceVariable»,«targetVariable»);'''
-                Modality modality)
-        {
-                '''find «modality.name.toLowerCase»InRelation«canonizeName('''«attribute.name» attribute «attribute.EContainingClass.name»''')
-                »(problem,interpretation,«sourceVariable»,«targetVariable»);'''
        }
-        
-        public def canonizeName(String name) {
+        def canonizeName(String name) {
                name.split(' ').join('_')
        }
-        
-        public def lowerMultiplicities(LogicProblem problem) {
+        def wfQueries(LogicProblem problem) {
-                problem.assertions.map[annotations].flatten.filter(LowerMultiplicityAssertion).filter[!it.relation.isDerived]
+                problem.assertions.map[it.annotations].flatten.filter(TransformedViatraWellformednessConstraint).map[it.query]
-        }
-        public def wfQueries(LogicProblem problem) {
-                problem.assertions.map[it.annotations]
-                        .flatten
-                        .filter(TransformedViatraWellformednessConstraint)
-                        .map[it.query]
        }
-        public def getContainments(LogicProblem p) {
+        def getContainments(LogicProblem p) {
                return p.containmentHierarchies.head.containmentRelations
        }
-        public def getInverseRelations(LogicProblem p) {
+        def getInverseRelations(LogicProblem p) {
                val inverseRelations = new HashMap
-                p.annotations.filter(InverseRelationAssertion).forEach[
+                p.annotations.filter(InverseRelationAssertion).forEach [
-                        inverseRelations.put(it.inverseA,it.inverseB)
+                        inverseRelations.put(it.inverseA, it.inverseB)
-                        inverseRelations.put(it.inverseB,it.inverseA)
+                        inverseRelations.put(it.inverseB, it.inverseA)
                ]
                return inverseRelations
        }
-        public def isRepresentative(Relation relation, Relation inverse) {
-                if(inverse == null) {
+        def isRepresentative(Relation relation, Relation inverse) {
+                if (relation === null) {
+                        return false
+                } else if (inverse === null) {
                        return true
                } else {
-                        relation.name.compareTo(inverse.name)<1
+                        relation.name.compareTo(inverse.name) < 1
                }
        }
-        
-        public def isDerived(Relation relation) {
+        def isDerived(Relation relation) {
                relation.annotations.exists[it instanceof DefinedByDerivedFeature]
        }
-        public def getDerivedDefinition(RelationDeclaration relation) {
+        def getDerivedDefinition(RelationDeclaration relation) {
                relation.annotations.filter(DefinedByDerivedFeature).head.query
        }
-        
        private def allTypeReferences(LogicProblem problem) {
                problem.eAllContents.filter(TypeReference).toIterable
        }
        protected def hasBoolean(LogicProblem problem) {
                problem.allTypeReferences.exists[it instanceof BoolTypeReference]
        }
        protected def hasInteger(LogicProblem problem) {
                problem.allTypeReferences.exists[it instanceof IntTypeReference]
        }
        protected def hasReal(LogicProblem problem) {
                problem.allTypeReferences.exists[it instanceof RealTypeReference]
        }
        protected def hasString(LogicProblem problem) {
                problem.allTypeReferences.exists[it instanceof StringTypeReference]
        }
-        
-        public def PatternGeneratorResult transformBaseProperties(
+        def transformBaseProperties(
                LogicProblem problem,
                PartialInterpretation emptySolution,
-                Map<String,PQuery> fqn2PQuery,
+                Map<String, PQuery> fqn2PQuery,
-                TypeAnalysisResult typeAnalysisResult
+                TypeAnalysisResult typeAnalysisResult,
+                RelationConstraints constraints,
+                Collection<LinearTypeConstraintHint> hints
        ) {
                val first = 
                 '''
@@ -199,7 +195,7 @@ class PatternGenerator {
                        
                        private pattern elementCloseWorld(element:DefinedElement) {
                                PartialInterpretation.openWorldElements(i,element);
-                            PartialInterpretation.maxNewElements(i,0);
+                                PartialInterpretation.maxNewElements(i,0);
                        } or {
                                Scope.targetTypeInterpretation(scope,interpretation);
                                PartialTypeInterpratation.elements(interpretation,element);
@@ -288,7 +284,9 @@ class PatternGenerator {
                        //////////
                        // 1.1.1 Required Patterns by TypeIndexer
                        //////////
                        «typeIndexer.requiredQueries»
+                        
                        //////////
                        // 1.1.2 primitive Type Indexers
                        //////////
@@ -306,6 +304,7 @@ class PatternGenerator {
                        // > StringElement.value(variableName,value)
                        // Whether a value is set is defined by:
                        // > PrimitiveElement.valueSet(variableName,isFilled);
+                        
                        //////////
                        // 1.1.3 domain-specific Type Indexers
                        //////////
@@ -338,7 +337,7 @@ class PatternGenerator {
                        //////////
                        // 3.1 Unfinishedness Measured by Multiplicity
                        //////////
-                        «unfinishedIndexer.generateUnfinishedMultiplicityQueries(problem,fqn2PQuery)»
+                        «unfinishedIndexer.generateUnfinishedMultiplicityQueries(constraints.multiplicityConstraints,fqn2PQuery)»
                        
                        //////////
                        // 3.2 Unfinishedness Measured by WF Queries
@@ -363,11 +362,18 @@ class PatternGenerator {
                        «relationRefinementGenerator.generateRefineReference(problem)»
                        
                        //////////
-                        // 5 Unit Propagations
+                        // 5 Hints
+                        //////////
+                        «FOR hint : hints»
+                                «hint.getAdditionalPatterns(this)»
+                        «ENDFOR»
+                        
+                        //////////
+                        // 6 Unit Propagations
                        //////////
                        '''
-                        val up = unitPropagationPreconditionGenerator.generateUnitPropagationRules(problem,problem.relations.filter(RelationDefinition),fqn2PQuery)
+                val up = unitPropagationPreconditionGenerator.generateUnitPropagationRules(problem,problem.relations.filter(RelationDefinition),fqn2PQuery)
-                        val second = up.definitions
+                val second = up.definitions
-                        return new PatternGeneratorResult(first+second,up.constraint2MustPreconditionName,up.constraint2CurrentPreconditionName)
+                return new PatternGeneratorResult(first+second,up.constraint2MustPreconditionName,up.constraint2CurrentPreconditionName)
        }
 }
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
index f3de4ccc..ac4a0855 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
@@ -2,78 +2,95 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysis
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearTypeConstraintHint
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.RelationConstraints
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.RelationMultiplicityConstraint
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagatorStrategy
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.util.ParseUtil
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
 import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace
+import java.util.Collection
+import java.util.HashMap
 import java.util.Map
+import java.util.Set
 import org.eclipse.viatra.query.runtime.api.IPatternMatch
 import org.eclipse.viatra.query.runtime.api.IQuerySpecification
 import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
 import org.eclipse.xtend.lib.annotations.Data
 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
-import java.util.Collection
-import java.util.Set
-import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint
-import java.util.HashMap
 @Data class GeneratedPatterns {
-        public Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidWFQueries
+        public Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidWFQueries
-        public Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWFQueries
+        public Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWFQueries
-        public Map<Relation,  Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> unfinishedContainmentMulticiplicityQueries
+        public Map<RelationMultiplicityConstraint, UnifinishedMultiplicityQueries> multiplicityConstraintQueries
-        public Map<Relation,  Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> unfinishedNonContainmentMulticiplicityQueries
+        public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hasElementInContainmentQuery
        public Map<ObjectCreationPrecondition,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineObjectQueries
-        public Map<? extends Type,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineTypeQueries
+        public Map<? extends Type, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineTypeQueries
        public Map<Pair<RelationDeclaration, Relation>,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refinerelationQueries
-        public Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>  mustUnitPropagationPreconditionPatterns
+        public Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> mustUnitPropagationPreconditionPatterns
-        public Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>  currentUnitPropagationPreconditionPatterns
+        public Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> currentUnitPropagationPreconditionPatterns
+        public Map<RelationDefinition, ModalPatternQueries> modalRelationQueries
        public Collection<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allQueries
 }
+@Data
+class ModalPatternQueries {
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> mayQuery
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> mustQuery
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> currentQuery
+}
+@Data
+class UnifinishedMultiplicityQueries {
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> unfinishedMultiplicityQuery
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> unrepairableMultiplicityQuery
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> remainingInverseMultiplicityQuery
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> remainingContentsQuery
+}
 class PatternProvider {
-        
        val TypeAnalysis typeAnalysis = new TypeAnalysis
-        
-        public def generateQueries(
+        def generateQueries(LogicProblem problem, PartialInterpretation emptySolution, ModelGenerationStatistics statistics,
-                LogicProblem problem,
+                Set<PQuery> existingQueries, ReasonerWorkspace workspace, TypeInferenceMethod typeInferenceMethod,
-                PartialInterpretation emptySolution,
+                ScopePropagatorStrategy scopePropagatorStrategy, RelationConstraints relationConstraints, 
-                ModelGenerationStatistics statistics,
+                Collection<LinearTypeConstraintHint> hints, boolean writeToFile) {
-                Set<PQuery> existingQueries,
-                ReasonerWorkspace workspace,
-                TypeInferenceMethod typeInferenceMethod,
-                boolean writeToFile)
-        {
                val fqn2Query = existingQueries.toMap[it.fullyQualifiedName]
-                val PatternGenerator patternGenerator = new PatternGenerator(typeInferenceMethod)
+                val PatternGenerator patternGenerator = new PatternGenerator(typeInferenceMethod, scopePropagatorStrategy)
-                val typeAnalysisResult = if(patternGenerator.requiresTypeAnalysis) {
+                val typeAnalysisResult = if (patternGenerator.requiresTypeAnalysis) {
-                        val startTime = System.nanoTime
+                                val startTime = System.nanoTime
-                        val result = typeAnalysis.performTypeAnalysis(problem,emptySolution)
+                                val result = typeAnalysis.performTypeAnalysis(problem, emptySolution)
-                        val typeAnalysisTime = System.nanoTime - startTime
+                                val typeAnalysisTime = System.nanoTime - startTime
-                        statistics.PreliminaryTypeAnalisisTime = typeAnalysisTime
+                                statistics.preliminaryTypeAnalisisTime = typeAnalysisTime
-                        result
+                                result
-                } else {
+                        } else {
-                        null
+                                null
-                }
+                        }
-                val patternGeneratorResult = patternGenerator.transformBaseProperties(problem,emptySolution,fqn2Query,typeAnalysisResult)
+                val patternGeneratorResult = patternGenerator.transformBaseProperties(problem, emptySolution, fqn2Query,
-                val baseIndexerFile = patternGeneratorResult.patternText
+                        typeAnalysisResult, relationConstraints, hints)
-                val mustUnitPropagationTrace = patternGeneratorResult.constraint2MustPreconditionName
+                if (writeToFile) {
-                val currentUnitPropagationTrace = patternGeneratorResult.constraint2CurrentPreconditionName
+                        workspace.writeText('''generated3valued.vql_deactivated''', patternGeneratorResult.patternText)
-                if(writeToFile) {
-                        workspace.writeText('''generated3valued.vql_deactivated''',baseIndexerFile)
                }
                val ParseUtil parseUtil = new ParseUtil
-                val generatedQueries = parseUtil.parse(baseIndexerFile)
+                val generatedQueries = parseUtil.parse(patternGeneratorResult.patternText)
-                val runtimeQueries = calclulateRuntimeQueries(patternGenerator,problem,emptySolution,typeAnalysisResult,mustUnitPropagationTrace,currentUnitPropagationTrace,generatedQueries);
+                val runtimeQueries = calclulateRuntimeQueries(patternGenerator, problem, emptySolution, typeAnalysisResult,
+                        patternGeneratorResult.constraint2MustPreconditionName, patternGeneratorResult.constraint2CurrentPreconditionName,
+                        relationConstraints, generatedQueries)
                return runtimeQueries
        }
-        
        private def GeneratedPatterns calclulateRuntimeQueries(
                PatternGenerator patternGenerator,
                LogicProblem problem,
@@ -81,31 +98,23 @@ class PatternProvider {
                TypeAnalysisResult typeAnalysisResult,
                HashMap<PConstraint, String> mustUnitPropagationTrace,
                HashMap<PConstraint, String> currentUnitPropagationTrace,
+                RelationConstraints relationConstraints,
                Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> queries
        ) {
-                val Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
+                val Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
                        invalidWFQueries = patternGenerator.invalidIndexer.getInvalidateByWfQueryNames(problem).mapValues[it.lookup(queries)]
-                val Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
+                val Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
                        unfinishedWFQueries = patternGenerator.unfinishedIndexer.getUnfinishedWFQueryNames(problem).mapValues[it.lookup(queries)]
                        
-                val unfinishedMultiplicities = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(problem)
+                val unfinishedMultiplicities = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(relationConstraints.multiplicityConstraints)
-                val unfinishedContainmentMultiplicities = new HashMap
+                val multiplicityConstraintQueries = unfinishedMultiplicities.mapValues [
-                val unfinishedNonContainmentMultiplicities = new HashMap
+                        new UnifinishedMultiplicityQueries(unfinishedMultiplicityQueryName?.lookup(queries),
-                for(entry : unfinishedMultiplicities.entrySet) {
+                                unrepairableMultiplicityQueryName?.lookup(queries),
-                        val relation = entry.key
+                                remainingInverseMultiplicityQueryName?.lookup(queries), remainingContentsQueryName?.lookup(queries))
-                        val name = entry.value.key
+                ]
-                        val amount = entry.value.value
+                val hasElementInContainmentQuery = patternGenerator.typeRefinementGenerator.hasElementInContainmentName.lookup(
-                        val query = name.lookup(queries)
+                        queries)
-                        if(problem.containmentHierarchies.head.containmentRelations.contains(relation)) {
-                                unfinishedContainmentMultiplicities.put(relation,query->amount)
-                        } else {
-                                unfinishedNonContainmentMultiplicities.put(relation,query->amount)
-                        }
-                }
-//              val Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
-//                      unfinishedMultiplicityQueries = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(problem).mapValues[it.lookup(queries)]
-//                      
-                        
                val Map<ObjectCreationPrecondition,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
                        refineObjectsQueries = patternGenerator.typeRefinementGenerator.getRefineObjectQueryNames(problem,emptySolution,typeAnalysisResult).mapValues[it.lookup(queries)]
                val Map<? extends Type,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
@@ -116,16 +125,27 @@ class PatternProvider {
                        mustUnitPropagationPreconditionPatterns = mustUnitPropagationTrace.mapValues[it.lookup(queries)]
                val Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> 
                        currentUnitPropagationPreconditionPatterns = currentUnitPropagationTrace.mapValues[it.lookup(queries)]
+                val modalRelationQueries = problem.relations.filter(RelationDefinition).toMap([it], [ relationDefinition |
+                        val indexer = patternGenerator.relationDefinitionIndexer
+                        new ModalPatternQueries(
+                                indexer.relationDefinitionName(relationDefinition, Modality.MAY).lookup(queries),
+                                indexer.relationDefinitionName(relationDefinition, Modality.MUST).lookup(queries),
+                                indexer.relationDefinitionName(relationDefinition, Modality.CURRENT).lookup(queries)
+                        )
+                ])
+                
                return new GeneratedPatterns(
                        invalidWFQueries,
                        unfinishedWFQueries,
-                        unfinishedContainmentMultiplicities,
+                        multiplicityConstraintQueries,
-                        unfinishedNonContainmentMultiplicities,
+                        hasElementInContainmentQuery,
                        refineObjectsQueries,
                        refineTypeQueries,
                        refineRelationQueries,
                        mustUnitPropagationPreconditionPatterns,
                        currentUnitPropagationPreconditionPatterns,
+                        modalRelationQueries,
                        queries.values
                )
        }
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
index 37950834..338a9af2 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
@@ -7,10 +7,10 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
 import java.util.Map
 import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable
 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PDisjunction
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PDisjunction
 class RelationDefinitionIndexer {
        public val PatternGenerator base;
@@ -60,7 +60,7 @@ class RelationDefinitionIndexer {
                ]
        }
        
-        private def relationDefinitionName(RelationDefinition relation, Modality modality)
+        def String relationDefinitionName(RelationDefinition relation, Modality modality)
                '''«modality.name.toLowerCase»InRelation_«base.canonizeName(relation.name)»'''
        
        def canonizeName(PVariable v) {
@@ -102,6 +102,4 @@ class RelationDefinitionIndexer {
        def referPattern(PQuery p, String[] variables, Modality modality, boolean positive, boolean transitive) '''
                «IF !positive»neg «ENDIF»find «IF transitive»twoParam_«ENDIF»«modality.name.toLowerCase»InRelation_pattern_«p.fullyQualifiedName.replace('.','_')»«IF transitive»+«ENDIF»(«IF !transitive»problem,interpretation,«ENDIF»«variables.join(',')»);
        '''
-        
-        
 }
 \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend
index f9e9baea..d915d47e 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend
@@ -9,77 +9,71 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
 class RelationRefinementGenerator {
        PatternGenerator base;
        public new(PatternGenerator base) {
                this.base = base
        }
-        
-        def CharSequence generateRefineReference(LogicProblem p) {
+        def CharSequence generateRefineReference(LogicProblem p) '''
-                return '''
+                «FOR relationRefinement : this.getRelationRefinements(p)»
-                «FOR relationRefinement: this.getRelationRefinements(p)»
+                        pattern «relationRefinementQueryName(relationRefinement.key,relationRefinement.value)»(
-                pattern «relationRefinementQueryName(relationRefinement.key,relationRefinement.value)»(
+                                problem:LogicProblem, interpretation:PartialInterpretation,
-                        problem:LogicProblem, interpretation:PartialInterpretation,
+                                relationIterpretation:PartialRelationInterpretation«IF relationRefinement.value !== null», oppositeInterpretation:PartialRelationInterpretation«ENDIF»,
-                        relationIterpretation:PartialRelationInterpretation«IF relationRefinement.value != null», oppositeInterpretation:PartialRelationInterpretation«ENDIF»,
+                                from: DefinedElement, to: DefinedElement)
-                        from: DefinedElement, to: DefinedElement)
+                        {
-                {
+                                find interpretation(problem,interpretation);
-                        find interpretation(problem,interpretation);
+                                PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);
-                        PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);
+                                PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«relationRefinement.key.name»");
-                        PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«relationRefinement.key.name»");
+                                «IF relationRefinement.value !== null»
-                        «IF relationRefinement.value != null»
+                                        PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation);
-                                PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation);
+                                        PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"«relationRefinement.value.name»");
-                                PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"«relationRefinement.value.name»");
+                                «ENDIF»
-                        «ENDIF»
+                                find mustExist(problem, interpretation, from);
-                        find mustExist(problem, interpretation, from);
+                                find mustExist(problem, interpretation, to);
-                        find mustExist(problem, interpretation, to);
+                                «base.typeIndexer.referInstanceOfByReference(relationRefinement.key.parameters.get(0), Modality::MUST,"from")»
-                        «base.typeIndexer.referInstanceOfByReference(relationRefinement.key.parameters.get(0), Modality::MUST,"from")»
+                                «base.typeIndexer.referInstanceOfByReference(relationRefinement.key.parameters.get(1), Modality::MUST,"to")»
-                        «base.typeIndexer.referInstanceOfByReference(relationRefinement.key.parameters.get(1), Modality::MUST,"to")»
+                                «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MAY)»
-                        «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MAY)»
+                                neg «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MUST)»
-                        neg «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MUST)»
+                        }
-                }
                «ENDFOR»
-                '''
+        '''
-        }
-        
        def String relationRefinementQueryName(RelationDeclaration relation, Relation inverseRelation) {
-                '''«IF inverseRelation != null
+                '''«IF inverseRelation !== null»refineRelation_«base.canonizeName(relation.name)»_and_«base.canonizeName(inverseRelation.name)»«ELSE»refineRelation_«base.canonizeName(relation.name)»«ENDIF»'''
-                »refineRelation_«base.canonizeName(relation.name)»_and_«base.canonizeName(inverseRelation.name)»«
-                        ELSE
-                »refineRelation_«base.canonizeName(relation.name)»«ENDIF»'''
        }
-        
        def referRefinementQuery(RelationDeclaration relation, Relation inverseRelation, String relInterpretationName,
-                String inverseInterpretationName, String sourceName, String targetName)
+                String inverseInterpretationName, String sourceName,
-        '''find «this.relationRefinementQueryName(relation,inverseRelation)»(problem, interpretation, «relInterpretationName», «IF inverseRelation != null»inverseInterpretationName, «ENDIF»«sourceName», «targetName»);'''
+                String targetName) '''find «this.relationRefinementQueryName(relation,inverseRelation)»(problem, interpretation, «relInterpretationName», «IF inverseRelation !== null»«inverseInterpretationName», «ENDIF»«sourceName», «targetName»);'''
-        
        def getRefineRelationQueries(LogicProblem p) {
 //              val containmentRelations = p.containmentHierarchies.map[containmentRelations].flatten.toSet
 //              p.relations.filter(RelationDeclaration).filter[!containmentRelations.contains(it)].toInvertedMap['''refineRelation_«base.canonizeName(it.name)»''']
                /*
-                val res = new LinkedHashMap
+                 * val res = new LinkedHashMap
-                for(relation: getRelationRefinements(p)) {
+                 * for(relation: getRelationRefinements(p)) {
-                        if(inverseRelations.containsKey(relation)) {
+                 *      if(inverseRelations.containsKey(relation)) {
-                                val name = '''refineRelation_«base.canonizeName(relation.name)»_and_«base.canonizeName(inverseRelations.get(relation).name)»'''
+                 *              val name = '''refineRelation_«base.canonizeName(relation.name)»_and_«base.canonizeName(inverseRelations.get(relation).name)»'''
-                                res.put(relation -> inverseRelations.get(relation),name)
+                 *              res.put(relation -> inverseRelations.get(relation),name)
-                        } else {
+                 *      } else {
-                                val name = '''refineRelation_«base.canonizeName(relation.name)»'''
+                 *              val name = '''refineRelation_«base.canonizeName(relation.name)»'''
-                                res.put(relation -> null,name)
+                 *              res.put(relation -> null,name)
-                        }
+                 *      }
-                }
+                 * }
-                return res*/
+                 return res*/
-                
+                getRelationRefinements(p).toInvertedMap[relationRefinementQueryName(it.key, it.value)]
-                getRelationRefinements(p).toInvertedMap[relationRefinementQueryName(it.key,it.value)]
        }
-        
        def getRelationRefinements(LogicProblem p) {
                val inverses = base.getInverseRelations(p)
                val containments = base.getContainments(p)
                val list = new LinkedList
-                for(relation : p.relations.filter(RelationDeclaration)) {
+                for (relation : p.relations.filter(RelationDeclaration)) {
-                        if(!containments.contains(relation)) {
+                        if (!containments.contains(relation)) {
-                                if(inverses.containsKey(relation)) {
+                                if (inverses.containsKey(relation)) {
                                        val inverse = inverses.get(relation)
-                                        if(!containments.contains(inverse)) {
+                                        if (!containments.contains(inverse)) {
-                                                if(base.isRepresentative(relation,inverse)) {
+                                                if (base.isRepresentative(relation, inverse)) {
                                                        list += (relation -> inverse)
                                                }
                                        }
@@ -90,4 +84,4 @@ class RelationRefinementGenerator {
                }
                return list
        }
-}
-\ No newline at end of file
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend
index 41eb75a8..e4e2aa30 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend
@@ -1,54 +1,126 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
-import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
-import org.eclipse.emf.ecore.EClass
-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntTypeReference
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealTypeReference
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.StringTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
 import java.math.BigDecimal
+import org.eclipse.emf.ecore.EClass
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+@FinalFieldsConstructor
 abstract class TypeIndexer {
-        public def CharSequence getRequiredQueries()
+        @Accessors(PROTECTED_GETTER) val PatternGenerator base
-        public def boolean requiresTypeAnalysis()
-        public def CharSequence generateInstanceOfQueries(LogicProblem problem,PartialInterpretation emptySolution,TypeAnalysisResult typeAnalysisResult)
+        def CharSequence getRequiredQueries() '''
-        public def CharSequence referInstanceOf(Type type, Modality modality, String variableName)
+                private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) {
-        public def CharSequence referInstanceOf(EClass type, Modality modality, String variableName)
+                        find interpretation(problem,interpretation);
-        
+                        LogicProblem.types(problem,type);
-        public def dispatch CharSequence referInstanceOfByReference(ComplexTypeReference reference, Modality modality, String variableName) {
+                        PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
-                reference.referred.referInstanceOf(modality,variableName)
+                        PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type);
-        }
+                }
-        public def dispatch CharSequence referInstanceOfByReference(BoolTypeReference reference, Modality modality, String variableName) {
+                
+                private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) {
+                        find interpretation(problem,interpretation);
+                        LogicProblem.types(problem,type);
+                        TypeDefinition.elements(type,element);
+                } or {
+                        find interpretation(problem,interpretation);
+                        find typeInterpretation(problem,interpretation,type,typeInterpretation);
+                        PartialComplexTypeInterpretation.elements(typeInterpretation,element);
+                }
+                
+                private pattern isPrimitive(element: PrimitiveElement) {
+                        PrimitiveElement(element);
+                }
+        '''
+        def boolean requiresTypeAnalysis()
+        def CharSequence generateInstanceOfQueries(LogicProblem problem, PartialInterpretation emptySolution,
+                TypeAnalysisResult typeAnalysisResult) '''
+                «FOR type : problem.types»
+                        «problem.generateMustInstenceOf(type, typeAnalysisResult)»
+                        «problem.generateMayInstanceOf(type, typeAnalysisResult)»
+                «ENDFOR»
+        '''
+        protected def CharSequence generateMustInstenceOf(LogicProblem problem, Type type,
+                TypeAnalysisResult typeAnalysisResult) '''
+                /**
+                 * An element must be an instance of type "«type.name»".
+                 */
+                private pattern «patternName(type,Modality.MUST)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
+                        Type.name(type,"«type.name»");
+                        find directInstanceOf(problem,interpretation,element,type);
+                }
+        '''
+        protected def CharSequence generateMayInstanceOf(LogicProblem problem, Type type,
+                TypeAnalysisResult typeAnalysisResult)
+        protected def patternName(Type type,
+                Modality modality) '''«modality.toBase»InstanceOf«base.canonizeName(type.name)»'''
+        def referInstanceOf(Type type, Modality modality, String variableName) {
+                '''find «patternName(type,modality)»(problem,interpretation,«variableName»);'''
+        }
+        def referInstanceOf(EClass type, Modality modality, String variableName) {
+                '''find «modality.toBase»InstanceOf«base.canonizeName('''«type.name» class''')»(problem,interpretation,«variableName»);'''
+        }
+        def dispatch CharSequence referInstanceOfByReference(ComplexTypeReference reference, Modality modality,
+                String variableName) {
+                reference.referred.referInstanceOf(modality, variableName)
+        }
+        def dispatch CharSequence referInstanceOfByReference(BoolTypeReference reference, Modality modality,
+                String variableName) {
                '''BooleanElement(«variableName»);'''
        }
-        public def dispatch CharSequence referInstanceOfByReference(IntTypeReference reference, Modality modality, String variableName) {
+        def dispatch CharSequence referInstanceOfByReference(IntTypeReference reference, Modality modality,
+                String variableName) {
                '''IntegerElement(«variableName»);'''
        }
-        public def dispatch CharSequence referInstanceOfByReference(RealTypeReference reference, Modality modality, String variableName) {
+        def dispatch CharSequence referInstanceOfByReference(RealTypeReference reference, Modality modality,
+                String variableName) {
                '''RealElement(«variableName»);'''
        }
-        public def dispatch CharSequence referInstanceOfByReference(StringTypeReference reference, Modality modality, String variableName) {
+        def dispatch CharSequence referInstanceOfByReference(StringTypeReference reference, Modality modality,
+                String variableName) {
                '''StringElement(«variableName»);'''
        }
-        public def dispatch CharSequence referPrimitiveValue(String variableName, Boolean value) {
+        def dispatch CharSequence referPrimitiveValue(String variableName, Boolean value) {
                '''BooleanElement.value(«variableName»,«value»);'''
        }
-        public def dispatch CharSequence referPrimitiveValue(String variableName, Integer value) {
+        def dispatch CharSequence referPrimitiveValue(String variableName, Integer value) {
                '''IntegerElement.value(«variableName»,«value»);'''
        }
-        public def dispatch CharSequence referPrimitiveValue(String variableName, BigDecimal value) {
+        def dispatch CharSequence referPrimitiveValue(String variableName, BigDecimal value) {
                '''RealElement.value(«variableName»,«value»);'''
        }
-        ///TODO: de-escaping string literals
-        public def dispatch CharSequence referPrimitiveValue(String variableName, String value) {
+        def dispatch CharSequence referPrimitiveValue(String variableName, String value) {
+                // /TODO: de-escaping string literals
                '''StringElement.value(«variableName»,"«value»");'''
        }
-        public def CharSequence referPrimitiveFilled(String variableName, boolean isFilled) {
+        def CharSequence referPrimitiveFilled(String variableName, boolean isFilled) {
                '''PrimitiveElement.valueSet(«variableName»,«isFilled»);'''
        }
-}
-\ No newline at end of file
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend
index d3af0426..0393b803 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend
@@ -4,113 +4,51 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeRefinementPrecondition
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
-import org.eclipse.emf.ecore.EClass
-class TypeIndexerWithPreliminaryTypeAnalysis extends TypeIndexer{
+class TypeIndexerWithPreliminaryTypeAnalysis extends TypeIndexer {
-        val PatternGenerator base;
-        
        new(PatternGenerator base) {
-                this.base = base
+                super(base)
        }
        override requiresTypeAnalysis() { true }
-        
-        override getRequiredQueries() '''
+        protected override generateMayInstanceOf(LogicProblem problem, Type type, TypeAnalysisResult typeAnalysisResult) {
-        private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) {
+                val precondition = typeAnalysisResult?.mayNewTypePreconditions?.get(type)
-                find interpretation(problem,interpretation);
+                val inhibitorTypes = precondition?.inhibitorTypes
-                LogicProblem.types(problem,type);
-                PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
-                PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type);
-        }
-        
-        private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) {
-                find interpretation(problem,interpretation);
-                LogicProblem.types(problem,type);
-                TypeDefinition.elements(type,element);
-        } or {
-                find interpretation(problem,interpretation);
-                find typeInterpretation(problem,interpretation,type,typeInterpretation);
-                PartialComplexTypeInterpretation.elements(typeInterpretation,element);
-        }
-        
-        private pattern isPrimitive(element: PrimitiveElement) {
-                PrimitiveElement(element);
-        }
-        '''
-        
-        override generateInstanceOfQueries(LogicProblem problem, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
-                val mayNewTypePreconditions = typeAnalysisResult.mayNewTypePreconditions
-                
-                return '''
-                «FOR type:problem.types»
-                        «problem.generateMustInstenceOf(type)»
-                        «problem.generateMayInstanceOf(type,mayNewTypePreconditions.get(type))»
-                «ENDFOR»
-                '''
-        }
-        
-        private def patternName(Type type, Modality modality)
-                '''«modality.toString.toLowerCase»InstanceOf«base.canonizeName(type.name)»'''
-        
-        private def generateMustInstenceOf(LogicProblem problem, Type type) {
-                '''
-                /**
-                 * An element must be an instance of type "«type.name»".
-                 */
-                private pattern «patternName(type,Modality.MUST)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
-                        Type.name(type,"«type.name»");
-                        find directInstanceOf(problem,interpretation,element,type);
-                }
-                '''
-        }
-        
-        private def generateMayInstanceOf(LogicProblem problem, Type type, TypeRefinementPrecondition precondition) {
-                val inhibitorTypes = if(precondition!=null) {
-                        precondition.inhibitorTypes
-                } else {
-                        null
-                }
                '''
-                private pattern scopeDisallowsNew«base.canonizeName(type.name)»(problem:LogicProblem, interpretation:PartialInterpretation) {
+                        private pattern scopeDisallowsNew«base.canonizeName(type.name)»(problem:LogicProblem, interpretation:PartialInterpretation) {
-                        find interpretation(problem,interpretation);
+                                find interpretation(problem,interpretation);
-                        PartialInterpretation.scopes(interpretation,scope);
+                                PartialInterpretation.scopes(interpretation,scope);
-                        Scope.targetTypeInterpretation(scope,typeInterpretation);
+                                Scope.targetTypeInterpretation(scope,typeInterpretation);
-                        Scope.maxNewElements(scope,0);
+                                Scope.maxNewElements(scope,0);
-                        PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type);
+                                PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type);
-                        Type.name(type,"«type.name»");
+                                Type.name(type,"«type.name»");
-                }
+                        }
-                
+                        
-                /**
+                        /**
-                 * An element may be an instance of type "«type.name»".
+                         * An element may be an instance of type "«type.name»".
-                 */
+                         */
-                private pattern «patternName(type,Modality.MAY)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement)
+                        private pattern «patternName(type,Modality.MAY)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement)
-                «IF inhibitorTypes !== null»{
+                        «IF inhibitorTypes !== null»
-                        find interpretation(problem,interpretation);
+                                {
-                        PartialInterpretation.newElements(interpretation,element);
+                                        find interpretation(problem,interpretation);
-                        «FOR inhibitorType : inhibitorTypes»
+                                        PartialInterpretation.newElements(interpretation,element);
-                                neg «referInstanceOf(inhibitorType,Modality.MUST,"element")»
+                                        «FOR inhibitorType : inhibitorTypes»
-                        «ENDFOR»
+                                                neg «referInstanceOf(inhibitorType,Modality.MUST,"element")»
-                        neg find scopeDisallowsNew«base.canonizeName(type.name)»(problem, interpretation);
+                                        «ENDFOR»
-                        neg find isPrimitive(element);
+                                        neg find scopeDisallowsNew«base.canonizeName(type.name)»(problem, interpretation);
-                } or {
+                                        neg find isPrimitive(element);
-                        find interpretation(problem,interpretation);
+                                } or {
-                        PartialInterpretation.openWorldElements(interpretation,element);
+                                        find interpretation(problem,interpretation);
-                        «FOR inhibitorType : inhibitorTypes»
+                                        PartialInterpretation.openWorldElements(interpretation,element);
-                                neg «referInstanceOf(inhibitorType,Modality.MUST,"element")»
+                                        «FOR inhibitorType : inhibitorTypes»
-                        «ENDFOR»
+                                                neg «referInstanceOf(inhibitorType,Modality.MUST,"element")»
-                        neg find scopeDisallowsNew«base.canonizeName(type.name)»(problem, interpretation);
+                                        «ENDFOR»
-                        neg find isPrimitive(element);
+                                        neg find scopeDisallowsNew«base.canonizeName(type.name)»(problem, interpretation);
-                } or
+                                        neg find isPrimitive(element);
-                «ENDIF»
+                                } or
-                { «referInstanceOf(type,Modality.MUST,"element")» }
+                        «ENDIF»
+                        { «referInstanceOf(type,Modality.MUST,"element")» }
                '''
        }
-        
+}
-        public override referInstanceOf(Type type, Modality modality, String variableName) {
-                '''find «patternName(type,modality)»(problem,interpretation,«variableName»);'''
-        }
-        public override referInstanceOf(EClass type, Modality modality, String variableName) {
-                '''find «modality.toString.toLowerCase»InstanceOf«base.canonizeName('''«type.name» class''')»(problem,interpretation,«variableName»);'''
-        }
-}
-\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementGenerator.xtend
index 7e3fad91..4ef336ae 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementGenerator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementGenerator.xtend
@@ -25,69 +25,76 @@ class ObjectCreationPrecondition {
 abstract class TypeRefinementGenerator {
        val protected PatternGenerator base;
-        public new(PatternGenerator base) {
+        new(PatternGenerator base) {
                this.base = base
        }
-        
-        public def boolean requiresTypeAnalysis()
+        def boolean requiresTypeAnalysis()
-        public def CharSequence generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult)
-        public def CharSequence generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult)
+        def CharSequence generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution,
-        public def Map<? extends Type, String> getRefineTypeQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult)
+                TypeAnalysisResult typeAnalysisResult)
-        
-        public def getRefineObjectQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
+        def CharSequence generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution,
-                val Map<ObjectCreationPrecondition,String> objectCreationQueries = new LinkedHashMap
+                TypeAnalysisResult typeAnalysisResult)
+        def Map<? extends Type, String> getRefineTypeQueryNames(LogicProblem p, PartialInterpretation emptySolution,
+                TypeAnalysisResult typeAnalysisResult)
+        def getRefineObjectQueryNames(LogicProblem p, PartialInterpretation emptySolution,
+                TypeAnalysisResult typeAnalysisResult) {
+                val Map<ObjectCreationPrecondition, String> objectCreationQueries = new LinkedHashMap
                val containment = p.containmentHierarchies.head
                val inverseRelations = new HashMap
-                p.annotations.filter(InverseRelationAssertion).forEach[
+                p.annotations.filter(InverseRelationAssertion).forEach [
-                        inverseRelations.put(it.inverseA,it.inverseB)
+                        inverseRelations.put(it.inverseA, it.inverseB)
-                        inverseRelations.put(it.inverseB,it.inverseA)
+                        inverseRelations.put(it.inverseB, it.inverseA)
                ]
-                for(type: p.types.filter(TypeDeclaration).filter[!it.isAbstract]) {
+                for (type : p.types.filter(TypeDeclaration).filter[!it.isAbstract]) {
-                        if(containment.typeInContainment(type)) {
+                        if (containment.typeInContainment(type)) {
-                                for(containmentRelation : containment.containmentRelations.filter[canBeContainedByRelation(it,type)]) {
+                                for (containmentRelation : containment.containmentRelations.
-                                        if(inverseRelations.containsKey(containmentRelation)) {
+                                        filter[canBeContainedByRelation(it, type)]) {
+                                        if (inverseRelations.containsKey(containmentRelation)) {
                                                objectCreationQueries.put(
-                                                        new ObjectCreationPrecondition(containmentRelation,inverseRelations.get(containmentRelation),type),
+                                                        new ObjectCreationPrecondition(containmentRelation,
-                                                        this.patternName(containmentRelation,inverseRelations.get(containmentRelation),type))
+                                                                inverseRelations.get(containmentRelation), type),
+                                                        this.patternName(containmentRelation, inverseRelations.get(containmentRelation), type))
                                        } else {
-                                                objectCreationQueries.put(
+                                                objectCreationQueries.put(new ObjectCreationPrecondition(containmentRelation, null, type),
-                                                        new ObjectCreationPrecondition(containmentRelation,null,type),
+                                                        patternName(containmentRelation, null, type))
-                                                        patternName(containmentRelation,null,type))
                                        }
                                }
-                                objectCreationQueries.put(
+                                objectCreationQueries.put(new ObjectCreationPrecondition(null, null, type),
-                                        new ObjectCreationPrecondition(null,null,type),
+                                        patternName(null, null, type))
-                                        patternName(null,null,type))
                        } else {
-                                objectCreationQueries.put(
+                                objectCreationQueries.put(new ObjectCreationPrecondition(null, null, type),
-                                        new ObjectCreationPrecondition(null,null,type),
+                                        this.patternName(null, null, type))
-                                        this.patternName(null,null,type))
                        }
                }
                return objectCreationQueries
        }
-        
        protected def canBeContainedByRelation(Relation r, Type t) {
-                if(r.parameters.size==2) {
+                if (r.parameters.size == 2) {
                        val param = r.parameters.get(1)
-                        if(param instanceof ComplexTypeReference) {
+                        if (param instanceof ComplexTypeReference) {
                                val allSuperTypes = t.transitiveClosureStar[it.supertypes]
-                                for(superType : allSuperTypes) {
+                                for (superType : allSuperTypes) {
                                        if(param.referred == superType) return true
                                }
                        }
                }
                return false
        }
-        
        private def typeInContainment(ContainmentHierarchy hierarchy, Type type) {
                val allSuperTypes = type.transitiveClosureStar[it.supertypes]
                return allSuperTypes.exists[hierarchy.typesOrderedInHierarchy.contains(it)]
        }
-        
        protected def String patternName(Relation containmentRelation, Relation inverseContainment, Type newType) {
-                if(containmentRelation != null) {
+                if (containmentRelation !== null) {
-                        if(inverseContainment != null) {
+                        if (inverseContainment !== null) {
                                '''createObject_«base.canonizeName(newType.name)»_by_«base.canonizeName(containmentRelation.name)»_with_«base.canonizeName(inverseContainment.name)»'''
                        } else {
                                '''createObject_«base.canonizeName(newType.name)»_by_«base.canonizeName(containmentRelation.name)»'''
@@ -96,4 +103,8 @@ abstract class TypeRefinementGenerator {
                        '''createObject_«base.canonizeName(newType.name)»'''
                }
        }
-}
-\ No newline at end of file
+        def hasElementInContainmentName() {
+                "hasElementInContainment"
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementWithPreliminaryTypeAnalysis.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementWithPreliminaryTypeAnalysis.xtend
index cbbbcb08..1a81695e 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementWithPreliminaryTypeAnalysis.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementWithPreliminaryTypeAnalysis.xtend
@@ -10,7 +10,7 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.par
 import java.util.HashMap
 class TypeRefinementWithPreliminaryTypeAnalysis extends TypeRefinementGenerator{
-        public new(PatternGenerator base) {
+        new(PatternGenerator base) {
                super(base)
        }
        override requiresTypeAnalysis() { true }
@@ -24,7 +24,7 @@ class TypeRefinementWithPreliminaryTypeAnalysis extends TypeRefinementGenerator{
                        inverseRelations.put(it.inverseB,it.inverseA)
                ]
                return '''
-                private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation)
+                pattern «hasElementInContainmentName»(problem:LogicProblem, interpretation:PartialInterpretation)
                «FOR type :containment.typesOrderedInHierarchy SEPARATOR "or"»{
                        find interpretation(problem,interpretation);
                        «base.typeIndexer.referInstanceOf(type,Modality.MUST,"root")»
@@ -76,7 +76,7 @@ class TypeRefinementWithPreliminaryTypeAnalysis extends TypeRefinementGenerator{
                                        typeInterpretation:PartialComplexTypeInterpretation)
                                {
                                        find interpretation(problem,interpretation);
-                                        neg find hasElementInContainment(problem,interpretation);
+                                        neg find «hasElementInContainmentName»(problem,interpretation);
                                        PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
                                        PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"«type.name»");
                                        «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend
index 1df402fa..a8a07756 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend
@@ -1,85 +1,204 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
-import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
-import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransformedViatraWellformednessConstraint
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.RelationMultiplicityConstraint
+import java.util.LinkedHashMap
+import java.util.List
 import java.util.Map
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
+import org.eclipse.xtend.lib.annotations.Data
 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
-import java.util.LinkedHashMap
-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
+@Data
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
+class UnifinishedMultiplicityQueryNames {
+        val String unfinishedMultiplicityQueryName
+        val String unrepairableMultiplicityQueryName
+        val String remainingInverseMultiplicityQueryName
+        val String remainingContentsQueryName
+}
 class UnfinishedIndexer {
        val PatternGenerator base
-        
+        val boolean indexUpperMultiplicities
-        new(PatternGenerator patternGenerator) {
+        new(PatternGenerator patternGenerator, boolean indexUpperMultiplicities) {
                this.base = patternGenerator
+                this.indexUpperMultiplicities = indexUpperMultiplicities
        }
-        
-        def generateUnfinishedWfQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) {
+        def generateUnfinishedWfQueries(LogicProblem problem, Map<String, PQuery> fqn2PQuery) {
                val wfQueries = base.wfQueries(problem)
                '''
-                «FOR wfQuery: wfQueries»
+                        «FOR wfQuery : wfQueries»
-                        pattern unfinishedBy_«base.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation,
+                                pattern unfinishedBy_«base.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation,
-                                «FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)
+                                        «FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)
-                        {
+                                {
-                                «base.relationDefinitionIndexer.referPattern(
+                                        «base.relationDefinitionIndexer.referPattern(
                                        wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery),
                                        wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters.map['''var_«it.name»'''],
                                        Modality.CURRENT,
                                        true,false)»
-                        }
+                                }
-                «ENDFOR»
+                        «ENDFOR»
                '''
        }
        def getUnfinishedWFQueryNames(LogicProblem problem) {
                val wfQueries = base.wfQueries(problem)
                val map = new LinkedHashMap
-                for(wfQuery : wfQueries) {
+                for (wfQuery : wfQueries) {
-                        map.put(wfQuery.target,'''unfinishedBy_«base.canonizeName(wfQuery.target.name)»''')
+                        map.put(wfQuery.target, '''unfinishedBy_«base.canonizeName(wfQuery.target.name)»''')
                }
                return map
        }
-        def generateUnfinishedMultiplicityQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) {
-                val lowerMultiplicities = base.lowerMultiplicities(problem)
+        def generateUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints,
-                return '''
+                Map<String, PQuery> fqn2PQuery) '''
-                «FOR lowerMultiplicity : lowerMultiplicities»
+                «FOR constraint : constraints»
-                        pattern «unfinishedMultiplicityName(lowerMultiplicity)»(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,numberOfExistingReferences) {
+                        «IF constraint.constrainsUnfinished»
-                                find interpretation(problem,interpretation);
+                                private pattern «unfinishedMultiplicityName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, missingMultiplicity:java Integer) {
-                                PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);
+                                        find interpretation(problem,interpretation);
-                                PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«lowerMultiplicity.relation.name»");
+                                        find mustExist(problem,interpretation,object);
-                                «base.typeIndexer.referInstanceOf(lowerMultiplicity.firstParamTypeOfRelation,Modality::MUST,"object")»
+                                        «base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»
-                                numberOfExistingReferences == count «base.referRelation(lowerMultiplicity.relation,"object","_",Modality.MUST,fqn2PQuery)»
+                                        numberOfExistingReferences == count «base.referRelation(constraint.relation,"object","_",Modality.MUST,fqn2PQuery)»
-«««                          numberOfExistingReferences < «lowerMultiplicity.lower»;
+                                        check(numberOfExistingReferences < «constraint.lowerBound»);
-«««                          missingMultiplicity == eval(«lowerMultiplicity.lower»-numberOfExistingReferences);
+                                        missingMultiplicity == eval(«constraint.lowerBound»-numberOfExistingReferences);
-                        }
+                                }
+                                
+                                pattern «unfinishedMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, missingMultiplicity:java Integer) {
+                                        find interpretation(problem,interpretation);
+                                        missingMultiplicity == sum find «unfinishedMultiplicityName(constraint)»_helper(problem, interpretation, _, #_);
+                                }
+                        «ENDIF»
+                        
+                        «IF indexUpperMultiplicities»
+                                «IF constraint.constrainsUnrepairable || constraint.constrainsRemainingInverse»
+                                        private pattern «repairMatchName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, source:DefinedElement, target:DefinedElement) {
+                                                «IF base.isRepresentative(constraint.relation, constraint.inverseRelation) && constraint.relation instanceof RelationDeclaration»
+                                                        «base.relationRefinementGenerator.referRefinementQuery(constraint.relation as RelationDeclaration, constraint.inverseRelation, "_", "_", "source", "target")»
+                                                «ELSE»
+                                                        «IF base.isRepresentative(constraint.inverseRelation, constraint.relation) && constraint.inverseRelation instanceof RelationDeclaration»
+                                                                «base.relationRefinementGenerator.referRefinementQuery(constraint.inverseRelation as RelationDeclaration, constraint.relation, "_", "_", "target", "source")»
+                                                        «ELSE»
+                                                                find interpretation(problem,interpretation);
+                                                                find mustExist(problem,interpretation,source);
+                                                                «base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"source")»
+                                                                find mustExist(problem,interpretation,target);
+                                                                «base.typeIndexer.referInstanceOf(constraint.targetType,Modality::MUST,"target")»
+                                                                neg «base.referRelation(constraint.relation,"source","target",Modality.MUST,fqn2PQuery)»
+                                                                «base.referRelation(constraint.relation,"source","target",Modality.MAY,fqn2PQuery)»
+                                                        «ENDIF»
+                                                «ENDIF»
+                                        }
+                                «ENDIF»
+                                
+                                «IF constraint.constrainsUnrepairable»
+                                        private pattern «unrepairableMultiplicityName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, unrepairableMultiplicity:java Integer) {
+                                                find «unfinishedMultiplicityName(constraint)»_helper(problem, interpretation, object, missingMultiplicity);
+                                                numberOfRepairMatches == count find «repairMatchName(constraint)»(problem, interpretation, object, _);
+                                                check(numberOfRepairMatches < missingMultiplicity);
+                                                unrepairableMultiplicity == eval(missingMultiplicity-numberOfRepairMatches);
+                                        }
+                                        
+                                        private pattern «unrepairableMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, unrepairableMultiplicity:java Integer) {
+                                                find interpretation(problem,interpretation);
+                                                unrepairableMultiplicity == max find «unrepairableMultiplicityName(constraint)»_helper(problem, interpretation, _, #_);
+                                        } or {
+                                                find interpretation(problem,interpretation);
+                                                neg find «unrepairableMultiplicityName(constraint)»_helper(problem, interpretation, _, _);
+                                                unrepairableMultiplicity == 0;
+                                        }
+                                «ENDIF»
+                                
+                                «IF constraint.constrainsRemainingInverse»
+                                        private pattern «remainingMultiplicityName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, remainingMultiplicity:java Integer) {
+                                                find interpretation(problem,interpretation);
+                                                find mustExist(problem,interpretation,object);
+                                                «base.typeIndexer.referInstanceOf(constraint.targetType,Modality::MUST,"object")»
+                                                numberOfExistingReferences == count «base.referRelation(constraint.relation,"_","object",Modality.MUST,fqn2PQuery)»
+                                                check(numberOfExistingReferences < «constraint.inverseUpperBound»);
+                                                numberOfRepairMatches == count find «repairMatchName(constraint)»(problem, interpretation, _, object);
+                                                remainingMultiplicity == eval(Math.min(«constraint.inverseUpperBound»-numberOfExistingReferences, numberOfRepairMatches));
+                                        }
+                                        
+                                        pattern «remainingMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, remainingMultiplicity:java Integer) {
+                                                find interpretation(problem,interpretation);
+                                                remainingMultiplicity == sum find «remainingMultiplicityName(constraint)»_helper(problem, interpretation, _, #_);
+                                        }
+                                «ENDIF»
+                                
+                                «IF constraint.constrainsRemainingContents»
+                                        «IF constraint.upperBoundFinite»
+                                                private pattern «remainingContentsName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, remainingMultiplicity:java Integer) {
+                                                        find interpretation(problem,interpretation);
+                                                        find mustExist(problem,interpretation,object);
+                                                        «base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»
+                                                        numberOfExistingReferences == count «base.referRelation(constraint.relation,"object","_",Modality.MUST,fqn2PQuery)»
+                                                        check(numberOfExistingReferences < «constraint.upperBound»);
+                                                        remainingMultiplicity == eval(«constraint.upperBound»-numberOfExistingReferences);
+                                                }
+                                                
+                                                pattern «remainingContentsName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, remainingMultiplicity:java Integer) {
+                                                        find interpretation(problem,interpretation);
+                                                        remainingMultiplicity == sum find «remainingContentsName(constraint)»_helper(problem, interpretation, _, #_);
+                                                }
+                                        «ELSE»
+                                                pattern «remainingContentsName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation) {
+                                                        find interpretation(problem,interpretation);
+                                                        find mustExist(problem,interpretation,object);
+                                                        «base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»
+                                                }
+                                                
+                                                pattern «remainingContentsName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, remainingMultiplicity:java Integer) {
+                                                        find interpretation(problem,interpretation);
+                                                        find «remainingContentsName(constraint)»_helper(problem, interpretation);
+                                                        remainingMultiplicity == -1;
+                                                } or {
+                                                        find interpretation(problem,interpretation);
+                                                        neg find «remainingContentsName(constraint)»_helper(problem, interpretation);
+                                                        remainingMultiplicity == 0;
+                                                }
+                                        «ENDIF»
+                                «ENDIF»
+                        «ENDIF»
                «ENDFOR»
-                '''
+        '''
-        }
-        def String unfinishedMultiplicityName(LowerMultiplicityAssertion lowerMultiplicityAssertion) 
+        def String unfinishedMultiplicityName(
-                '''unfinishedLowerMultiplicity_«base.canonizeName(lowerMultiplicityAssertion.relation.name)»'''
+                RelationMultiplicityConstraint constraint) '''unfinishedLowerMultiplicity_«base.canonizeName(constraint.relation.name)»'''
-        
-        //def public referUnfinishedMultiplicityQuery(LowerMultiplicityAssertion lowerMultiplicityAssertion)
+        def String unrepairableMultiplicityName(
-        //      '''find «unfinishedMultiplicityName(lowerMultiplicityAssertion)»(problem, interpretation ,object, missingMultiplicity);'''
+                RelationMultiplicityConstraint constraint) '''unrepairableLowerMultiplicity_«base.canonizeName(constraint.relation.name)»'''
-        
-        def getFirstParamTypeOfRelation(LowerMultiplicityAssertion lowerMultiplicityAssertion) {
+        private def String repairMatchName(
-                val parameters = lowerMultiplicityAssertion.relation.parameters
+                RelationMultiplicityConstraint constraint) '''repair_«base.canonizeName(constraint.relation.name)»'''
-                if(parameters.size == 2) {
-                        val firstParam = parameters.get(0)
+        def String remainingMultiplicityName(
-                        if(firstParam instanceof ComplexTypeReference) {
+                RelationMultiplicityConstraint constraint) '''remainingInverseUpperMultiplicity_«base.canonizeName(constraint.relation.name)»'''
-                                return firstParam.referred
-                        }
+        def String remainingContentsName(
-                }
+                RelationMultiplicityConstraint constraint) '''remainingContents_«base.canonizeName(constraint.relation.name)»'''
-        }
-        
+        def getUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints) {
-        def getUnfinishedMultiplicityQueries(LogicProblem problem) {
+                constraints.toInvertedMap [ constraint |
-                val lowerMultiplicities = base.lowerMultiplicities(problem)
+                        new UnifinishedMultiplicityQueryNames(
-                val map = new LinkedHashMap
+                                if(constraint.constrainsUnfinished) unfinishedMultiplicityName(constraint) else null,
-                for(lowerMultiplicity : lowerMultiplicities) {
+                                if (indexUpperMultiplicities && constraint.constrainsUnrepairable)
-                        map.put(lowerMultiplicity.relation,unfinishedMultiplicityName(lowerMultiplicity)->lowerMultiplicity.lower)
+                                        unrepairableMultiplicityName(constraint)
-                }
+                                else
-                return map
+                                        null,
+                                if (indexUpperMultiplicities && constraint.constrainsRemainingInverse)
+                                        remainingMultiplicityName(constraint)
+                                else
+                                        null,
+                                if (indexUpperMultiplicities && constraint.constrainsRemainingContents)
+                                        remainingContentsName(constraint)
+                                else
+                                        null
+                        )
+                ]
        }
 }
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
index e03a8c35..238ade5b 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
@@ -1,98 +1,26 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules
-import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.MultiplicityGoalConstraintCalculator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.MultiplicityGoalConstraintCalculator
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns
 import java.util.ArrayList
-import java.util.HashMap
-import java.util.LinkedList
-import java.util.List
-import java.util.Map
-import org.eclipse.viatra.query.runtime.api.IPatternMatch
-import org.eclipse.viatra.query.runtime.api.IQuerySpecification
-import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
-import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
 class GoalConstraintProvider {
        
-        def public getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns, boolean calculateObjectCost) {
+        def getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns) {
                val res = new ArrayList()
-                
+                for (entry : patterns.multiplicityConstraintQueries.entrySet) {
-                res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false)
+                        val constraint = entry.key
-                if(calculateObjectCost) {
+                        if (constraint.constrainsUnfinished) {
-                        val missingObjectCost = calculateMissingObjectCost(p)
+                                val queries = entry.value
-                        res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true,missingObjectCost)
+                                val targetRelationName = constraint.relation.name
-                } else {
+                                val query = queries.unfinishedMultiplicityQuery
-                        res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true)
+                                val minValue = constraint.lowerBound
-                }
+                                val containment = constraint.containment
-                return res
+                                res += new MultiplicityGoalConstraintCalculator(targetRelationName, query, minValue, containment, 1)
-        }
-        
-        def addAll(ArrayList<MultiplicityGoalConstraintCalculator> res, Map<Relation, Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> queries, boolean containment) {
-                for(multiplicityQuery : queries.entrySet) {
-                        val targetRelationName = multiplicityQuery.key.name
-                        val query = multiplicityQuery.value.key
-                        val minValue = multiplicityQuery.value.value
-                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,1);
-                }
-        }
-        def addAll(
-                ArrayList<MultiplicityGoalConstraintCalculator> res,
-                Map<Relation, Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> queries,
-                boolean containment,
-                Map<Relation, Integer> cost
-        ) {
-                for(multiplicityQuery : queries.entrySet) {
-                        val targetRelationName = multiplicityQuery.key.name
-                        val query = multiplicityQuery.value.key
-                        val minValue = multiplicityQuery.value.value
-                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,multiplicityQuery.key.lookup(cost))
-                }
-        }
-        
-        def calculateMissingObjectCost(LogicProblem p) {
-                val containments = p.containmentHierarchies.head.containmentRelations
-                val containment2Lower = containments.toInvertedMap[containment | 
-                        val lower = p.annotations.filter(LowerMultiplicityAssertion).filter[it.relation === containment].head
-                        if(lower !== null) { lower.lower }
-                        else { 0 }
-                ]
-                val types = p.types
-                val Map<Type,List<? extends Pair<Type,Integer>>> type2NewCost = new HashMap
-                for(type:types) {
-                        val allSupertypes = (#[type] + type.supertypes).toSet
-                        val allOutgoingContainments = containments.filter[allSupertypes.contains((it.parameters.get(0) as ComplexTypeReference).referred)]
-                        val list = new LinkedList
-                        for(outgoingContainment : allOutgoingContainments) {
-                                val value = containment2Lower.get(outgoingContainment)
-                                if(value>0) {
-                                        list.add((outgoingContainment.parameters.get(1) as ComplexTypeReference).referred
-                                                        ->      value)
-                                }
                        }
-                        type2NewCost.put(type, list)
-                }
-                val res = new HashMap
-                for(containment : containments) {
-                        val key = containment
-                        val value = (containment.parameters.get(1) as ComplexTypeReference).referred.count(type2NewCost)
-//                      println('''«key.name» --> «value» new''')
-                        res.put(key,value)
                }
                return res
        }
-        
-        private def int count(Type t, Map<Type,List<? extends Pair<Type,Integer>>> containments) {
-                val list = containments.get(t)
-                var r = 1
-                for(element : list) {
-                        r += element.value * element.key.count(containments)
-                }
-                return r
-        }
 }
 \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
index 23ea118b..0b8a9019 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
@@ -15,7 +15,7 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.StringTypeReference
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics
-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ScopePropagator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagator
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.ObjectCreationPrecondition
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialBooleanInterpretation
@@ -84,13 +84,13 @@ class RefinementRuleProvider {
        {
                val name = '''addObject_«type.name.canonizeName»«
                                        IF containmentRelation!==null»_by_«containmentRelation.name.canonizeName»«ENDIF»'''
-                val ruleBuilder = factory.createRule
+                val ruleBuilder = factory.createRule(lhs)
                                .name(name)
-                                .precondition(lhs)
                if(containmentRelation !== null) {
                        if(inverseRelation!== null) {
                                ruleBuilder.action[match |
-                                        //println(name)
+                                        statistics.incrementTransformationCount
+//                                      println(name)
                                        val startTime = System.nanoTime
                                        //val problem = match.get(0) as LogicProblem
                                        val interpretation = match.get(1) as PartialInterpretation
@@ -111,11 +111,17 @@ class RefinementRuleProvider {
                                                scopePropagator
                                        )
                                        
-                                        statistics.addExecutionTime(System.nanoTime-startTime)
+                                        val propagatorStartTime = System.nanoTime
+                                        statistics.addExecutionTime(propagatorStartTime-startTime)
+                                        
+                                        // Scope propagation
+                                        scopePropagator.propagateAllScopeConstraints()
+                                        statistics.addScopePropagationTime(System.nanoTime-propagatorStartTime)
                                ]
                        } else {
                                ruleBuilder.action[match |
-                                        //println(name)
+                                        statistics.incrementTransformationCount
+//                                      println(name)
                                        val startTime = System.nanoTime
                                        //val problem = match.get(0) as LogicProblem
                                        val interpretation = match.get(1) as PartialInterpretation
@@ -134,17 +140,23 @@ class RefinementRuleProvider {
                                                scopePropagator
                                        )
                                        
-                                        statistics.addExecutionTime(System.nanoTime-startTime)
+                                        val propagatorStartTime = System.nanoTime
+                                        statistics.addExecutionTime(propagatorStartTime-startTime)
+                                        
+                                        // Scope propagation
+                                        scopePropagator.propagateAllScopeConstraints()
+                                        statistics.addScopePropagationTime(System.nanoTime-propagatorStartTime)
                                ]
                        }
                } else {
                        ruleBuilder.action[match |
-                                //println(name)
+                                statistics.incrementTransformationCount
+//                              println(name)
                                val startTime = System.nanoTime
                                //val problem = match.get(0) as LogicProblem
                                val interpretation = match.get(1) as PartialInterpretation
                                val typeInterpretation = match.get(2) as PartialComplexTypeInterpretation
-                                
                                createObjectAction(
                                        nameNewElement,
                                        interpretation,
@@ -154,14 +166,18 @@ class RefinementRuleProvider {
                                        scopePropagator
                                )
                                
-                                statistics.addExecutionTime(System.nanoTime-startTime)
+                                val propagatorStartTime = System.nanoTime
+                                statistics.addExecutionTime(propagatorStartTime-startTime)
+                                
+                                // Scope propagation
+                                scopePropagator.propagateAllScopeConstraints()
+                                statistics.addScopePropagationTime(System.nanoTime-propagatorStartTime)
                        ]
                }
                return ruleBuilder.build
        }
        
-        def private recursiveObjectCreation(LogicProblem p, PartialInterpretation i)
+        def private recursiveObjectCreation(LogicProblem p, PartialInterpretation i) {
-        {
                val Map<Type,List<ObjectCreationInterpretationData>> recursiveObjectCreation = new HashMap
                for(type : p.types) {
                        recursiveObjectCreation.put(type,new LinkedList)
@@ -305,49 +321,64 @@ class RefinementRuleProvider {
        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialStringInterpretation reference) { [createStringElement] }
        
        
-        def createRelationRefinementRules(GeneratedPatterns patterns, ModelGenerationStatistics statistics) {
+        def createRelationRefinementRules(GeneratedPatterns patterns, ScopePropagator scopePropagator, ModelGenerationStatistics statistics) {
                val res = new LinkedHashMap
                for(LHSEntry: patterns.refinerelationQueries.entrySet) {
                        val declaration = LHSEntry.key.key
                        val inverseReference = LHSEntry.key.value
                        val lhs = LHSEntry.value as IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>>
-                        val rule = createRelationRefinementRule(declaration,inverseReference,lhs,statistics)
+                        val rule = createRelationRefinementRule(declaration,inverseReference,lhs,scopePropagator,statistics)
                        res.put(LHSEntry.key,rule)
                }
                return res
        }
        
        def private BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>
-                createRelationRefinementRule(RelationDeclaration declaration, Relation inverseRelation, IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, ModelGenerationStatistics statistics)
+                createRelationRefinementRule(RelationDeclaration declaration, Relation inverseRelation, IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, ScopePropagator scopePropagator, ModelGenerationStatistics statistics)
        {
                val name = '''addRelation_«declaration.name.canonizeName»«IF inverseRelation !== null»_and_«inverseRelation.name.canonizeName»«ENDIF»'''
-                val ruleBuilder = factory.createRule
+                val ruleBuilder = factory.createRule(lhs)
                        .name(name)
-                        .precondition(lhs)
                if (inverseRelation === null) {
                        ruleBuilder.action [ match |
+                                statistics.incrementTransformationCount
                            val startTime = System.nanoTime
-                                //println(name)
+//                              println(name)
                                // val problem = match.get(0) as LogicProblem
                                // val interpretation = match.get(1) as PartialInterpretation
                                val relationInterpretation = match.get(2) as PartialRelationInterpretation
                                val src = match.get(3) as DefinedElement
                                val trg = match.get(4) as DefinedElement
+                                
                                createRelationLinkAction(src, trg, relationInterpretation)
-                statistics.addExecutionTime(System.nanoTime-startTime)
+                                
+                                val propagatorStartTime = System.nanoTime
+                                statistics.addExecutionTime(propagatorStartTime-startTime)
+                                
+                                // Scope propagation
+                                scopePropagator.propagateAdditionToRelation(declaration)
+                                statistics.addScopePropagationTime(System.nanoTime-propagatorStartTime)
                        ]
                } else {
                        ruleBuilder.action [ match |
+                                statistics.incrementTransformationCount
                            val startTime = System.nanoTime
-                                //println(name)
+//                              println(name)
                                // val problem = match.get(0) as LogicProblem
                                // val interpretation = match.get(1) as PartialInterpretation
                                val relationInterpretation = match.get(2) as PartialRelationInterpretation
                                val inverseInterpretation = match.get(3) as PartialRelationInterpretation
                                val src = match.get(4) as DefinedElement
                                val trg = match.get(5) as DefinedElement
                                createRelationLinkWithInverse(src, trg, relationInterpretation, inverseInterpretation)
-                                statistics.addExecutionTime(System.nanoTime-startTime)
+                                
+                                val propagatorStartTime = System.nanoTime
+                                statistics.addExecutionTime(propagatorStartTime-startTime)
+                                
+                                // Scope propagation
+                                scopePropagator.propagateAdditionToRelation(declaration)
+                                statistics.addScopePropagationTime(System.nanoTime-propagatorStartTime)
                        ]
                }
@@ -426,7 +457,7 @@ class RefinementRuleProvider {
                inverseRelationInterpretation.relationlinks+=newLink2
                
                // Scope propagation
-                scopePropagator.propagateAdditionToType(typeInterpretation)
+                scopePropagator.decrementTypeScope(typeInterpretation)
                
                // Existence
                interpretation.newElements+=newElement
@@ -464,7 +495,7 @@ class RefinementRuleProvider {
                relationInterpretation.relationlinks+=newLink
                
                // Scope propagation
-                scopePropagator.propagateAdditionToType(typeInterpretation)
+                scopePropagator.decrementTypeScope(typeInterpretation)
                
                // Existence
                interpretation.newElements+=newElement
@@ -497,7 +528,7 @@ class RefinementRuleProvider {
                }
                
                // Scope propagation
-                scopePropagator.propagateAdditionToType(typeInterpretation)
+                scopePropagator.decrementTypeScope(typeInterpretation)
                
                // Existence
                interpretation.newElements+=newElement
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/PartialInterpretation.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/PartialInterpretation.java
index 098cc15b..9d0c3fea 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/PartialInterpretation.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/PartialInterpretation.java
@@ -30,6 +30,7 @@ import org.eclipse.emf.ecore.EObject;
 *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation#getScopes <em>Scopes</em>}</li>
 *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation#getMinNewElements <em>Min New Elements</em>}</li>
 *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation#getMaxNewElements <em>Max New Elements</em>}</li>
+ *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation#getMinNewElementsHeuristic <em>Min New Elements Heuristic</em>}</li>
 * </ul>
 *
 * @see hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage#getPartialInterpretation()
@@ -255,4 +256,27 @@ public interface PartialInterpretation extends EObject {
         */
        void setMaxNewElements(int value);
+        /**
+         * Returns the value of the '<em><b>Min New Elements Heuristic</b></em>' attribute.
+         * The default value is <code>"0"</code>.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @return the value of the '<em>Min New Elements Heuristic</em>' attribute.
+         * @see #setMinNewElementsHeuristic(int)
+         * @see hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage#getPartialInterpretation_MinNewElementsHeuristic()
+         * @model default="0" required="true"
+         * @generated
+         */
+        int getMinNewElementsHeuristic();
+        /**
+         * Sets the value of the '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation#getMinNewElementsHeuristic <em>Min New Elements Heuristic</em>}' attribute.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @param value the new value of the '<em>Min New Elements Heuristic</em>' attribute.
+         * @see #getMinNewElementsHeuristic()
+         * @generated
+         */
+        void setMinNewElementsHeuristic(int value);
 } // PartialInterpretation
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/PartialinterpretationPackage.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/PartialinterpretationPackage.java
index 4f34b9b7..f462ebe4 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/PartialinterpretationPackage.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/PartialinterpretationPackage.java
@@ -167,13 +167,22 @@ public interface PartialinterpretationPackage extends EPackage {
        int PARTIAL_INTERPRETATION__MAX_NEW_ELEMENTS = 10;
        /**
+         * The feature id for the '<em><b>Min New Elements Heuristic</b></em>' attribute.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         * @ordered
+         */
+        int PARTIAL_INTERPRETATION__MIN_NEW_ELEMENTS_HEURISTIC = 11;
+        /**
         * The number of structural features of the '<em>Partial Interpretation</em>' class.
         * <!-- begin-user-doc -->
         * <!-- end-user-doc -->
         * @generated
         * @ordered
         */
-        int PARTIAL_INTERPRETATION_FEATURE_COUNT = 11;
+        int PARTIAL_INTERPRETATION_FEATURE_COUNT = 12;
        /**
         * The number of operations of the '<em>Partial Interpretation</em>' class.
@@ -913,13 +922,22 @@ public interface PartialinterpretationPackage extends EPackage {
        int SCOPE__TARGET_TYPE_INTERPRETATION = 2;
        /**
+         * The feature id for the '<em><b>Min New Elements Heuristic</b></em>' attribute.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         * @ordered
+         */
+        int SCOPE__MIN_NEW_ELEMENTS_HEURISTIC = 3;
+        /**
         * The number of structural features of the '<em>Scope</em>' class.
         * <!-- begin-user-doc -->
         * <!-- end-user-doc -->
         * @generated
         * @ordered
         */
-        int SCOPE_FEATURE_COUNT = 3;
+        int SCOPE_FEATURE_COUNT = 4;
        /**
         * The number of operations of the '<em>Scope</em>' class.
@@ -1358,6 +1376,17 @@ public interface PartialinterpretationPackage extends EPackage {
        EAttribute getPartialInterpretation_MaxNewElements();
        /**
+         * Returns the meta object for the attribute '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation#getMinNewElementsHeuristic <em>Min New Elements Heuristic</em>}'.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @return the meta object for the attribute '<em>Min New Elements Heuristic</em>'.
+         * @see hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation#getMinNewElementsHeuristic()
+         * @see #getPartialInterpretation()
+         * @generated
+         */
+        EAttribute getPartialInterpretation_MinNewElementsHeuristic();
+        /**
         * Returns the meta object for class '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialConstantInterpretation <em>Partial Constant Interpretation</em>}'.
         * <!-- begin-user-doc -->
         * <!-- end-user-doc -->
@@ -1750,6 +1779,17 @@ public interface PartialinterpretationPackage extends EPackage {
        EReference getScope_TargetTypeInterpretation();
        /**
+         * Returns the meta object for the attribute '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope#getMinNewElementsHeuristic <em>Min New Elements Heuristic</em>}'.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @return the meta object for the attribute '<em>Min New Elements Heuristic</em>'.
+         * @see hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope#getMinNewElementsHeuristic()
+         * @see #getScope()
+         * @generated
+         */
+        EAttribute getScope_MinNewElementsHeuristic();
+        /**
         * Returns the meta object for class '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation <em>Partial Primitive Interpretation</em>}'.
         * <!-- begin-user-doc -->
         * <!-- end-user-doc -->
@@ -1953,6 +1993,14 @@ public interface PartialinterpretationPackage extends EPackage {
                EAttribute PARTIAL_INTERPRETATION__MAX_NEW_ELEMENTS = eINSTANCE.getPartialInterpretation_MaxNewElements();
                /**
+                 * The meta object literal for the '<em><b>Min New Elements Heuristic</b></em>' attribute feature.
+                 * <!-- begin-user-doc -->
+                 * <!-- end-user-doc -->
+                 * @generated
+                 */
+                EAttribute PARTIAL_INTERPRETATION__MIN_NEW_ELEMENTS_HEURISTIC = eINSTANCE.getPartialInterpretation_MinNewElementsHeuristic();
+                /**
                 * The meta object literal for the '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.PartialConstantInterpretationImpl <em>Partial Constant Interpretation</em>}' class.
                 * <!-- begin-user-doc -->
                 * <!-- end-user-doc -->
@@ -2279,6 +2327,14 @@ public interface PartialinterpretationPackage extends EPackage {
                EReference SCOPE__TARGET_TYPE_INTERPRETATION = eINSTANCE.getScope_TargetTypeInterpretation();
                /**
+                 * The meta object literal for the '<em><b>Min New Elements Heuristic</b></em>' attribute feature.
+                 * <!-- begin-user-doc -->
+                 * <!-- end-user-doc -->
+                 * @generated
+                 */
+                EAttribute SCOPE__MIN_NEW_ELEMENTS_HEURISTIC = eINSTANCE.getScope_MinNewElementsHeuristic();
+                /**
                 * The meta object literal for the '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.PartialPrimitiveInterpretationImpl <em>Partial Primitive Interpretation</em>}' class.
                 * <!-- begin-user-doc -->
                 * <!-- end-user-doc -->
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/Scope.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/Scope.java
index 155b9f00..a0b58615 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/Scope.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/Scope.java
@@ -16,6 +16,7 @@ import org.eclipse.emf.ecore.EObject;
 *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope#getMinNewElements <em>Min New Elements</em>}</li>
 *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope#getMaxNewElements <em>Max New Elements</em>}</li>
 *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope#getTargetTypeInterpretation <em>Target Type Interpretation</em>}</li>
+ *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope#getMinNewElementsHeuristic <em>Min New Elements Heuristic</em>}</li>
 * </ul>
 *
 * @see hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage#getScope()
@@ -105,4 +106,27 @@ public interface Scope extends EObject {
         */
        void setTargetTypeInterpretation(PartialTypeInterpratation value);
+        /**
+         * Returns the value of the '<em><b>Min New Elements Heuristic</b></em>' attribute.
+         * The default value is <code>"0"</code>.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @return the value of the '<em>Min New Elements Heuristic</em>' attribute.
+         * @see #setMinNewElementsHeuristic(int)
+         * @see hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage#getScope_MinNewElementsHeuristic()
+         * @model default="0" required="true"
+         * @generated
+         */
+        int getMinNewElementsHeuristic();
+        /**
+         * Sets the value of the '{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope#getMinNewElementsHeuristic <em>Min New Elements Heuristic</em>}' attribute.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @param value the new value of the '<em>Min New Elements Heuristic</em>' attribute.
+         * @see #getMinNewElementsHeuristic()
+         * @generated
+         */
+        void setMinNewElementsHeuristic(int value);
 } // Scope
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/BinaryElementRelationLinkImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/BinaryElementRelationLinkImpl.java
index f5efe02a..ca33dd65 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/BinaryElementRelationLinkImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/BinaryElementRelationLinkImpl.java
@@ -73,6 +73,7 @@ public class BinaryElementRelationLinkImpl extends RelationLinkImpl implements B
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public DefinedElement getParam1() {
                if (param1 != null && param1.eIsProxy()) {
                        InternalEObject oldParam1 = (InternalEObject)param1;
@@ -99,6 +100,7 @@ public class BinaryElementRelationLinkImpl extends RelationLinkImpl implements B
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setParam1(DefinedElement newParam1) {
                DefinedElement oldParam1 = param1;
                param1 = newParam1;
@@ -111,6 +113,7 @@ public class BinaryElementRelationLinkImpl extends RelationLinkImpl implements B
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public DefinedElement getParam2() {
                if (param2 != null && param2.eIsProxy()) {
                        InternalEObject oldParam2 = (InternalEObject)param2;
@@ -137,6 +140,7 @@ public class BinaryElementRelationLinkImpl extends RelationLinkImpl implements B
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setParam2(DefinedElement newParam2) {
                DefinedElement oldParam2 = param2;
                param2 = newParam2;
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/BooleanElementImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/BooleanElementImpl.java
index e906e07d..5f12d9e4 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/BooleanElementImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/BooleanElementImpl.java
@@ -69,6 +69,7 @@ public class BooleanElementImpl extends PrimitiveElementImpl implements BooleanE
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public boolean isValue() {
                return value;
        }
@@ -78,6 +79,7 @@ public class BooleanElementImpl extends PrimitiveElementImpl implements BooleanE
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setValue(boolean newValue) {
                boolean oldValue = value;
                value = newValue;
@@ -152,7 +154,7 @@ public class BooleanElementImpl extends PrimitiveElementImpl implements BooleanE
        public String toString() {
                if (eIsProxy()) return super.toString();
-                StringBuffer result = new StringBuffer(super.toString());
+                StringBuilder result = new StringBuilder(super.toString());
                result.append(" (value: ");
                result.append(value);
                result.append(')');
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/IntegerElementImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/IntegerElementImpl.java
index ef1a4b96..c8fbe1dd 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/IntegerElementImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/IntegerElementImpl.java
@@ -69,6 +69,7 @@ public class IntegerElementImpl extends PrimitiveElementImpl implements IntegerE
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public int getValue() {
                return value;
        }
@@ -78,6 +79,7 @@ public class IntegerElementImpl extends PrimitiveElementImpl implements IntegerE
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setValue(int newValue) {
                int oldValue = value;
                value = newValue;
@@ -152,7 +154,7 @@ public class IntegerElementImpl extends PrimitiveElementImpl implements IntegerE
        public String toString() {
                if (eIsProxy()) return super.toString();
-                StringBuffer result = new StringBuffer(super.toString());
+                StringBuilder result = new StringBuilder(super.toString());
                result.append(" (value: ");
                result.append(value);
                result.append(')');
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/NaryRelationLinkElementImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/NaryRelationLinkElementImpl.java
index 749a03c5..c319a3f4 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/NaryRelationLinkElementImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/NaryRelationLinkElementImpl.java
@@ -83,6 +83,7 @@ public class NaryRelationLinkElementImpl extends MinimalEObjectImpl.Container im
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public int getIndex() {
                return index;
        }
@@ -92,6 +93,7 @@ public class NaryRelationLinkElementImpl extends MinimalEObjectImpl.Container im
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setIndex(int newIndex) {
                int oldIndex = index;
                index = newIndex;
@@ -104,6 +106,7 @@ public class NaryRelationLinkElementImpl extends MinimalEObjectImpl.Container im
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public DefinedElement getParam() {
                if (param != null && param.eIsProxy()) {
                        InternalEObject oldParam = (InternalEObject)param;
@@ -130,6 +133,7 @@ public class NaryRelationLinkElementImpl extends MinimalEObjectImpl.Container im
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setParam(DefinedElement newParam) {
                DefinedElement oldParam = param;
                param = newParam;
@@ -215,7 +219,7 @@ public class NaryRelationLinkElementImpl extends MinimalEObjectImpl.Container im
        public String toString() {
                if (eIsProxy()) return super.toString();
-                StringBuffer result = new StringBuffer(super.toString());
+                StringBuilder result = new StringBuilder(super.toString());
                result.append(" (index: ");
                result.append(index);
                result.append(')');
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/NaryRelationLinkImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/NaryRelationLinkImpl.java
index f387ee06..9f7628cf 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/NaryRelationLinkImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/NaryRelationLinkImpl.java
@@ -66,6 +66,7 @@ public class NaryRelationLinkImpl extends RelationLinkImpl implements NaryRelati
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EList<NaryRelationLinkElement> getElements() {
                if (elements == null) {
                        elements = new EObjectContainmentEList<NaryRelationLinkElement>(NaryRelationLinkElement.class, this, PartialinterpretationPackage.NARY_RELATION_LINK__ELEMENTS);
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialComplexTypeInterpretationImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialComplexTypeInterpretationImpl.java
index 07ee282d..c00b4278 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialComplexTypeInterpretationImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialComplexTypeInterpretationImpl.java
@@ -79,6 +79,7 @@ public class PartialComplexTypeInterpretationImpl extends PartialTypeInterpratat
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EList<PartialComplexTypeInterpretation> getSupertypeInterpretation() {
                if (supertypeInterpretation == null) {
                        supertypeInterpretation = new EObjectResolvingEList<PartialComplexTypeInterpretation>(PartialComplexTypeInterpretation.class, this, PartialinterpretationPackage.PARTIAL_COMPLEX_TYPE_INTERPRETATION__SUPERTYPE_INTERPRETATION);
@@ -91,6 +92,7 @@ public class PartialComplexTypeInterpretationImpl extends PartialTypeInterpratat
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public TypeDeclaration getInterpretationOf() {
                if (interpretationOf != null && interpretationOf.eIsProxy()) {
                        InternalEObject oldInterpretationOf = (InternalEObject)interpretationOf;
@@ -117,6 +119,7 @@ public class PartialComplexTypeInterpretationImpl extends PartialTypeInterpratat
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setInterpretationOf(TypeDeclaration newInterpretationOf) {
                TypeDeclaration oldInterpretationOf = interpretationOf;
                interpretationOf = newInterpretationOf;
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialConstantInterpretationImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialConstantInterpretationImpl.java
index 81b2ce8d..6d51f0db 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialConstantInterpretationImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialConstantInterpretationImpl.java
@@ -63,6 +63,7 @@ public class PartialConstantInterpretationImpl extends MinimalEObjectImpl.Contai
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public ConstantDeclaration getInterpretationOf() {
                if (interpretationOf != null && interpretationOf.eIsProxy()) {
                        InternalEObject oldInterpretationOf = (InternalEObject)interpretationOf;
@@ -89,6 +90,7 @@ public class PartialConstantInterpretationImpl extends MinimalEObjectImpl.Contai
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setInterpretationOf(ConstantDeclaration newInterpretationOf) {
                ConstantDeclaration oldInterpretationOf = interpretationOf;
                interpretationOf = newInterpretationOf;
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialFunctionInterpretationImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialFunctionInterpretationImpl.java
index 2d361e8e..855c4abc 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialFunctionInterpretationImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialFunctionInterpretationImpl.java
@@ -63,6 +63,7 @@ public class PartialFunctionInterpretationImpl extends MinimalEObjectImpl.Contai
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public FunctionDeclaration getInterpretationOf() {
                if (interpretationOf != null && interpretationOf.eIsProxy()) {
                        InternalEObject oldInterpretationOf = (InternalEObject)interpretationOf;
@@ -89,6 +90,7 @@ public class PartialFunctionInterpretationImpl extends MinimalEObjectImpl.Contai
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setInterpretationOf(FunctionDeclaration newInterpretationOf) {
                FunctionDeclaration oldInterpretationOf = interpretationOf;
                interpretationOf = newInterpretationOf;
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialInterpretationImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialInterpretationImpl.java
index bce3e2e0..9afdd8d2 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialInterpretationImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialInterpretationImpl.java
@@ -47,6 +47,7 @@ import org.eclipse.emf.ecore.util.InternalEList;
 *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.PartialInterpretationImpl#getScopes <em>Scopes</em>}</li>
 *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.PartialInterpretationImpl#getMinNewElements <em>Min New Elements</em>}</li>
 *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.PartialInterpretationImpl#getMaxNewElements <em>Max New Elements</em>}</li>
+ *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.PartialInterpretationImpl#getMinNewElementsHeuristic <em>Min New Elements Heuristic</em>}</li>
 * </ul>
 *
 * @generated
@@ -183,6 +184,26 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
        protected int maxNewElements = MAX_NEW_ELEMENTS_EDEFAULT;
        /**
+         * The default value of the '{@link #getMinNewElementsHeuristic() <em>Min New Elements Heuristic</em>}' attribute.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @see #getMinNewElementsHeuristic()
+         * @generated
+         * @ordered
+         */
+        protected static final int MIN_NEW_ELEMENTS_HEURISTIC_EDEFAULT = 0;
+        /**
+         * The cached value of the '{@link #getMinNewElementsHeuristic() <em>Min New Elements Heuristic</em>}' attribute.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @see #getMinNewElementsHeuristic()
+         * @generated
+         * @ordered
+         */
+        protected int minNewElementsHeuristic = MIN_NEW_ELEMENTS_HEURISTIC_EDEFAULT;
+        /**
         * <!-- begin-user-doc -->
         * <!-- end-user-doc -->
         * @generated
@@ -206,6 +227,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public LogicProblem getProblem() {
                if (problem != null && problem.eIsProxy()) {
                        InternalEObject oldProblem = (InternalEObject)problem;
@@ -232,6 +254,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setProblem(LogicProblem newProblem) {
                LogicProblem oldProblem = problem;
                problem = newProblem;
@@ -244,6 +267,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EList<PartialConstantInterpretation> getPartialconstantinterpretation() {
                if (partialconstantinterpretation == null) {
                        partialconstantinterpretation = new EObjectContainmentEList<PartialConstantInterpretation>(PartialConstantInterpretation.class, this, PartialinterpretationPackage.PARTIAL_INTERPRETATION__PARTIALCONSTANTINTERPRETATION);
@@ -256,6 +280,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EList<PartialRelationInterpretation> getPartialrelationinterpretation() {
                if (partialrelationinterpretation == null) {
                        partialrelationinterpretation = new EObjectContainmentEList<PartialRelationInterpretation>(PartialRelationInterpretation.class, this, PartialinterpretationPackage.PARTIAL_INTERPRETATION__PARTIALRELATIONINTERPRETATION);
@@ -268,6 +293,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EList<PartialFunctionInterpretation> getPartialfunctioninterpretation() {
                if (partialfunctioninterpretation == null) {
                        partialfunctioninterpretation = new EObjectContainmentEList<PartialFunctionInterpretation>(PartialFunctionInterpretation.class, this, PartialinterpretationPackage.PARTIAL_INTERPRETATION__PARTIALFUNCTIONINTERPRETATION);
@@ -280,6 +306,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EList<DefinedElement> getNewElements() {
                if (newElements == null) {
                        newElements = new EObjectContainmentEList<DefinedElement>(DefinedElement.class, this, PartialinterpretationPackage.PARTIAL_INTERPRETATION__NEW_ELEMENTS);
@@ -292,6 +319,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EList<PartialTypeInterpratation> getPartialtypeinterpratation() {
                if (partialtypeinterpratation == null) {
                        partialtypeinterpratation = new EObjectContainmentEList<PartialTypeInterpratation>(PartialTypeInterpratation.class, this, PartialinterpretationPackage.PARTIAL_INTERPRETATION__PARTIALTYPEINTERPRATATION);
@@ -304,6 +332,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EList<DefinedElement> getOpenWorldElements() {
                if (openWorldElements == null) {
                        openWorldElements = new EObjectContainmentEList<DefinedElement>(DefinedElement.class, this, PartialinterpretationPackage.PARTIAL_INTERPRETATION__OPEN_WORLD_ELEMENTS);
@@ -316,6 +345,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public LogicProblem getProblemConainer() {
                return problemConainer;
        }
@@ -340,6 +370,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setProblemConainer(LogicProblem newProblemConainer) {
                if (newProblemConainer != problemConainer) {
                        NotificationChain msgs = null;
@@ -359,6 +390,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EList<Scope> getScopes() {
                if (scopes == null) {
                        scopes = new EObjectContainmentEList<Scope>(Scope.class, this, PartialinterpretationPackage.PARTIAL_INTERPRETATION__SCOPES);
@@ -371,6 +403,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public int getMinNewElements() {
                return minNewElements;
        }
@@ -380,6 +413,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setMinNewElements(int newMinNewElements) {
                int oldMinNewElements = minNewElements;
                minNewElements = newMinNewElements;
@@ -392,6 +426,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public int getMaxNewElements() {
                return maxNewElements;
        }
@@ -401,6 +436,7 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setMaxNewElements(int newMaxNewElements) {
                int oldMaxNewElements = maxNewElements;
                maxNewElements = newMaxNewElements;
@@ -414,6 +450,29 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
         * @generated
         */
        @Override
+        public int getMinNewElementsHeuristic() {
+                return minNewElementsHeuristic;
+        }
+        /**
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        @Override
+        public void setMinNewElementsHeuristic(int newMinNewElementsHeuristic) {
+                int oldMinNewElementsHeuristic = minNewElementsHeuristic;
+                minNewElementsHeuristic = newMinNewElementsHeuristic;
+                if (eNotificationRequired())
+                        eNotify(new ENotificationImpl(this, Notification.SET, PartialinterpretationPackage.PARTIAL_INTERPRETATION__MIN_NEW_ELEMENTS_HEURISTIC, oldMinNewElementsHeuristic, minNewElementsHeuristic));
+        }
+        /**
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        @Override
        public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
                switch (featureID) {
                        case PartialinterpretationPackage.PARTIAL_INTERPRETATION__PARTIALCONSTANTINTERPRETATION:
@@ -467,6 +526,8 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
                                return getMinNewElements();
                        case PartialinterpretationPackage.PARTIAL_INTERPRETATION__MAX_NEW_ELEMENTS:
                                return getMaxNewElements();
+                        case PartialinterpretationPackage.PARTIAL_INTERPRETATION__MIN_NEW_ELEMENTS_HEURISTIC:
+                                return getMinNewElementsHeuristic();
                }
                return super.eGet(featureID, resolve, coreType);
        }
@@ -520,6 +581,9 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
                        case PartialinterpretationPackage.PARTIAL_INTERPRETATION__MAX_NEW_ELEMENTS:
                                setMaxNewElements((Integer)newValue);
                                return;
+                        case PartialinterpretationPackage.PARTIAL_INTERPRETATION__MIN_NEW_ELEMENTS_HEURISTIC:
+                                setMinNewElementsHeuristic((Integer)newValue);
+                                return;
                }
                super.eSet(featureID, newValue);
        }
@@ -565,6 +629,9 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
                        case PartialinterpretationPackage.PARTIAL_INTERPRETATION__MAX_NEW_ELEMENTS:
                                setMaxNewElements(MAX_NEW_ELEMENTS_EDEFAULT);
                                return;
+                        case PartialinterpretationPackage.PARTIAL_INTERPRETATION__MIN_NEW_ELEMENTS_HEURISTIC:
+                                setMinNewElementsHeuristic(MIN_NEW_ELEMENTS_HEURISTIC_EDEFAULT);
+                                return;
                }
                super.eUnset(featureID);
        }
@@ -599,6 +666,8 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
                                return minNewElements != MIN_NEW_ELEMENTS_EDEFAULT;
                        case PartialinterpretationPackage.PARTIAL_INTERPRETATION__MAX_NEW_ELEMENTS:
                                return maxNewElements != MAX_NEW_ELEMENTS_EDEFAULT;
+                        case PartialinterpretationPackage.PARTIAL_INTERPRETATION__MIN_NEW_ELEMENTS_HEURISTIC:
+                                return minNewElementsHeuristic != MIN_NEW_ELEMENTS_HEURISTIC_EDEFAULT;
                }
                return super.eIsSet(featureID);
        }
@@ -612,11 +681,13 @@ public class PartialInterpretationImpl extends MinimalEObjectImpl.Container impl
        public String toString() {
                if (eIsProxy()) return super.toString();
-                StringBuffer result = new StringBuffer(super.toString());
+                StringBuilder result = new StringBuilder(super.toString());
                result.append(" (minNewElements: ");
                result.append(minNewElements);
                result.append(", maxNewElements: ");
                result.append(maxNewElements);
+                result.append(", minNewElementsHeuristic: ");
+                result.append(minNewElementsHeuristic);
                result.append(')');
                return result.toString();
        }
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialRelationInterpretationImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialRelationInterpretationImpl.java
index 71aef9af..7ad06504 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialRelationInterpretationImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialRelationInterpretationImpl.java
@@ -106,6 +106,7 @@ public class PartialRelationInterpretationImpl extends MinimalEObjectImpl.Contai
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public RelationDeclaration getInterpretationOf() {
                if (interpretationOf != null && interpretationOf.eIsProxy()) {
                        InternalEObject oldInterpretationOf = (InternalEObject)interpretationOf;
@@ -132,6 +133,7 @@ public class PartialRelationInterpretationImpl extends MinimalEObjectImpl.Contai
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setInterpretationOf(RelationDeclaration newInterpretationOf) {
                RelationDeclaration oldInterpretationOf = interpretationOf;
                interpretationOf = newInterpretationOf;
@@ -144,6 +146,7 @@ public class PartialRelationInterpretationImpl extends MinimalEObjectImpl.Contai
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EList<RelationLink> getRelationlinks() {
                if (relationlinks == null) {
                        relationlinks = new EObjectContainmentEList<RelationLink>(RelationLink.class, this, PartialinterpretationPackage.PARTIAL_RELATION_INTERPRETATION__RELATIONLINKS);
@@ -156,6 +159,7 @@ public class PartialRelationInterpretationImpl extends MinimalEObjectImpl.Contai
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public TypeReference getParam1() {
                if (param1 != null && param1.eIsProxy()) {
                        InternalEObject oldParam1 = (InternalEObject)param1;
@@ -182,6 +186,7 @@ public class PartialRelationInterpretationImpl extends MinimalEObjectImpl.Contai
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setParam1(TypeReference newParam1) {
                TypeReference oldParam1 = param1;
                param1 = newParam1;
@@ -194,6 +199,7 @@ public class PartialRelationInterpretationImpl extends MinimalEObjectImpl.Contai
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public TypeReference getParam2() {
                if (param2 != null && param2.eIsProxy()) {
                        InternalEObject oldParam2 = (InternalEObject)param2;
@@ -220,6 +226,7 @@ public class PartialRelationInterpretationImpl extends MinimalEObjectImpl.Contai
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setParam2(TypeReference newParam2) {
                TypeReference oldParam2 = param2;
                param2 = newParam2;
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialTypeInterpratationImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialTypeInterpratationImpl.java
index da9b1472..51eabd2c 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialTypeInterpratationImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialTypeInterpratationImpl.java
@@ -76,6 +76,7 @@ public abstract class PartialTypeInterpratationImpl extends MinimalEObjectImpl.C
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EList<DefinedElement> getElements() {
                if (elements == null) {
                        elements = new EObjectResolvingEList<DefinedElement>(DefinedElement.class, this, PartialinterpretationPackage.PARTIAL_TYPE_INTERPRATATION__ELEMENTS);
@@ -88,6 +89,7 @@ public abstract class PartialTypeInterpratationImpl extends MinimalEObjectImpl.C
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EList<Scope> getScopes() {
                if (scopes == null) {
                        scopes = new EObjectWithInverseResolvingEList<Scope>(Scope.class, this, PartialinterpretationPackage.PARTIAL_TYPE_INTERPRATATION__SCOPES, PartialinterpretationPackage.SCOPE__TARGET_TYPE_INTERPRETATION);
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialinterpretationFactoryImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialinterpretationFactoryImpl.java
index af1db8a1..06ca4e37 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialinterpretationFactoryImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialinterpretationFactoryImpl.java
@@ -84,6 +84,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public PartialInterpretation createPartialInterpretation() {
                PartialInterpretationImpl partialInterpretation = new PartialInterpretationImpl();
                return partialInterpretation;
@@ -94,6 +95,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public PartialConstantInterpretation createPartialConstantInterpretation() {
                PartialConstantInterpretationImpl partialConstantInterpretation = new PartialConstantInterpretationImpl();
                return partialConstantInterpretation;
@@ -104,6 +106,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public PartialRelationInterpretation createPartialRelationInterpretation() {
                PartialRelationInterpretationImpl partialRelationInterpretation = new PartialRelationInterpretationImpl();
                return partialRelationInterpretation;
@@ -114,6 +117,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public PartialFunctionInterpretation createPartialFunctionInterpretation() {
                PartialFunctionInterpretationImpl partialFunctionInterpretation = new PartialFunctionInterpretationImpl();
                return partialFunctionInterpretation;
@@ -124,6 +128,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public UnaryElementRelationLink createUnaryElementRelationLink() {
                UnaryElementRelationLinkImpl unaryElementRelationLink = new UnaryElementRelationLinkImpl();
                return unaryElementRelationLink;
@@ -134,6 +139,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public BinaryElementRelationLink createBinaryElementRelationLink() {
                BinaryElementRelationLinkImpl binaryElementRelationLink = new BinaryElementRelationLinkImpl();
                return binaryElementRelationLink;
@@ -144,6 +150,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public NaryRelationLink createNaryRelationLink() {
                NaryRelationLinkImpl naryRelationLink = new NaryRelationLinkImpl();
                return naryRelationLink;
@@ -154,6 +161,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public NaryRelationLinkElement createNaryRelationLinkElement() {
                NaryRelationLinkElementImpl naryRelationLinkElement = new NaryRelationLinkElementImpl();
                return naryRelationLinkElement;
@@ -164,6 +172,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public BooleanElement createBooleanElement() {
                BooleanElementImpl booleanElement = new BooleanElementImpl();
                return booleanElement;
@@ -174,6 +183,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public IntegerElement createIntegerElement() {
                IntegerElementImpl integerElement = new IntegerElementImpl();
                return integerElement;
@@ -184,6 +194,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public RealElement createRealElement() {
                RealElementImpl realElement = new RealElementImpl();
                return realElement;
@@ -194,6 +205,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public StringElement createStringElement() {
                StringElementImpl stringElement = new StringElementImpl();
                return stringElement;
@@ -204,6 +216,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public Scope createScope() {
                ScopeImpl scope = new ScopeImpl();
                return scope;
@@ -214,6 +227,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public PartialBooleanInterpretation createPartialBooleanInterpretation() {
                PartialBooleanInterpretationImpl partialBooleanInterpretation = new PartialBooleanInterpretationImpl();
                return partialBooleanInterpretation;
@@ -224,6 +238,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public PartialIntegerInterpretation createPartialIntegerInterpretation() {
                PartialIntegerInterpretationImpl partialIntegerInterpretation = new PartialIntegerInterpretationImpl();
                return partialIntegerInterpretation;
@@ -234,6 +249,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public PartialRealInterpretation createPartialRealInterpretation() {
                PartialRealInterpretationImpl partialRealInterpretation = new PartialRealInterpretationImpl();
                return partialRealInterpretation;
@@ -244,6 +260,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public PartialStringInterpretation createPartialStringInterpretation() {
                PartialStringInterpretationImpl partialStringInterpretation = new PartialStringInterpretationImpl();
                return partialStringInterpretation;
@@ -254,6 +271,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public PartialComplexTypeInterpretation createPartialComplexTypeInterpretation() {
                PartialComplexTypeInterpretationImpl partialComplexTypeInterpretation = new PartialComplexTypeInterpretationImpl();
                return partialComplexTypeInterpretation;
@@ -264,6 +282,7 @@ public class PartialinterpretationFactoryImpl extends EFactoryImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public PartialinterpretationPackage getPartialinterpretationPackage() {
                return (PartialinterpretationPackage)getEPackage();
        }
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialinterpretationPackageImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialinterpretationPackageImpl.java
index a21dc306..1ea3a11d 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialinterpretationPackageImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PartialinterpretationPackageImpl.java
@@ -227,7 +227,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
        /**
         * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
-         * 
+         *
         * <p>This method is used to initialize {@link PartialinterpretationPackage#eINSTANCE} when that field is accessed.
         * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
         * <!-- begin-user-doc -->
@@ -241,7 +241,8 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
                if (isInited) return (PartialinterpretationPackage)EPackage.Registry.INSTANCE.getEPackage(PartialinterpretationPackage.eNS_URI);
                // Obtain or create and register package
-                PartialinterpretationPackageImpl thePartialinterpretationPackage = (PartialinterpretationPackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof PartialinterpretationPackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new PartialinterpretationPackageImpl());
+                Object registeredPartialinterpretationPackage = EPackage.Registry.INSTANCE.get(eNS_URI);
+                PartialinterpretationPackageImpl thePartialinterpretationPackage = registeredPartialinterpretationPackage instanceof PartialinterpretationPackageImpl ? (PartialinterpretationPackageImpl)registeredPartialinterpretationPackage : new PartialinterpretationPackageImpl();
                isInited = true;
@@ -258,7 +259,6 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
                // Mark meta-data to indicate it can't be changed
                thePartialinterpretationPackage.freeze();
-  
                // Update the registry and return the package
                EPackage.Registry.INSTANCE.put(PartialinterpretationPackage.eNS_URI, thePartialinterpretationPackage);
                return thePartialinterpretationPackage;
@@ -269,6 +269,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getPartialInterpretation() {
                return partialInterpretationEClass;
        }
@@ -278,6 +279,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialInterpretation_Problem() {
                return (EReference)partialInterpretationEClass.getEStructuralFeatures().get(0);
        }
@@ -287,6 +289,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialInterpretation_Partialconstantinterpretation() {
                return (EReference)partialInterpretationEClass.getEStructuralFeatures().get(1);
        }
@@ -296,6 +299,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialInterpretation_Partialrelationinterpretation() {
                return (EReference)partialInterpretationEClass.getEStructuralFeatures().get(2);
        }
@@ -305,6 +309,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialInterpretation_Partialfunctioninterpretation() {
                return (EReference)partialInterpretationEClass.getEStructuralFeatures().get(3);
        }
@@ -314,6 +319,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialInterpretation_NewElements() {
                return (EReference)partialInterpretationEClass.getEStructuralFeatures().get(4);
        }
@@ -323,6 +329,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialInterpretation_Partialtypeinterpratation() {
                return (EReference)partialInterpretationEClass.getEStructuralFeatures().get(5);
        }
@@ -332,6 +339,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialInterpretation_OpenWorldElements() {
                return (EReference)partialInterpretationEClass.getEStructuralFeatures().get(6);
        }
@@ -341,6 +349,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialInterpretation_ProblemConainer() {
                return (EReference)partialInterpretationEClass.getEStructuralFeatures().get(7);
        }
@@ -350,6 +359,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialInterpretation_Scopes() {
                return (EReference)partialInterpretationEClass.getEStructuralFeatures().get(8);
        }
@@ -359,6 +369,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EAttribute getPartialInterpretation_MinNewElements() {
                return (EAttribute)partialInterpretationEClass.getEStructuralFeatures().get(9);
        }
@@ -368,6 +379,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EAttribute getPartialInterpretation_MaxNewElements() {
                return (EAttribute)partialInterpretationEClass.getEStructuralFeatures().get(10);
        }
@@ -377,6 +389,17 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
+        public EAttribute getPartialInterpretation_MinNewElementsHeuristic() {
+                return (EAttribute)partialInterpretationEClass.getEStructuralFeatures().get(11);
+        }
+        /**
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        @Override
        public EClass getPartialConstantInterpretation() {
                return partialConstantInterpretationEClass;
        }
@@ -386,6 +409,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialConstantInterpretation_InterpretationOf() {
                return (EReference)partialConstantInterpretationEClass.getEStructuralFeatures().get(0);
        }
@@ -395,6 +419,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getPartialRelationInterpretation() {
                return partialRelationInterpretationEClass;
        }
@@ -404,6 +429,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialRelationInterpretation_InterpretationOf() {
                return (EReference)partialRelationInterpretationEClass.getEStructuralFeatures().get(0);
        }
@@ -413,6 +439,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialRelationInterpretation_Relationlinks() {
                return (EReference)partialRelationInterpretationEClass.getEStructuralFeatures().get(1);
        }
@@ -422,6 +449,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialRelationInterpretation_Param1() {
                return (EReference)partialRelationInterpretationEClass.getEStructuralFeatures().get(2);
        }
@@ -431,6 +459,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialRelationInterpretation_Param2() {
                return (EReference)partialRelationInterpretationEClass.getEStructuralFeatures().get(3);
        }
@@ -440,6 +469,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getPartialFunctionInterpretation() {
                return partialFunctionInterpretationEClass;
        }
@@ -449,6 +479,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialFunctionInterpretation_InterpretationOf() {
                return (EReference)partialFunctionInterpretationEClass.getEStructuralFeatures().get(0);
        }
@@ -458,6 +489,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getPartialTypeInterpratation() {
                return partialTypeInterpratationEClass;
        }
@@ -467,6 +499,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialTypeInterpratation_Elements() {
                return (EReference)partialTypeInterpratationEClass.getEStructuralFeatures().get(0);
        }
@@ -476,6 +509,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialTypeInterpratation_Scopes() {
                return (EReference)partialTypeInterpratationEClass.getEStructuralFeatures().get(1);
        }
@@ -485,6 +519,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getRelationLink() {
                return relationLinkEClass;
        }
@@ -494,6 +529,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getUnaryElementRelationLink() {
                return unaryElementRelationLinkEClass;
        }
@@ -503,6 +539,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getUnaryElementRelationLink_Param1() {
                return (EReference)unaryElementRelationLinkEClass.getEStructuralFeatures().get(0);
        }
@@ -512,6 +549,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getBinaryElementRelationLink() {
                return binaryElementRelationLinkEClass;
        }
@@ -521,6 +559,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getBinaryElementRelationLink_Param1() {
                return (EReference)binaryElementRelationLinkEClass.getEStructuralFeatures().get(0);
        }
@@ -530,6 +569,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getBinaryElementRelationLink_Param2() {
                return (EReference)binaryElementRelationLinkEClass.getEStructuralFeatures().get(1);
        }
@@ -539,6 +579,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getNaryRelationLink() {
                return naryRelationLinkEClass;
        }
@@ -548,6 +589,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getNaryRelationLink_Elements() {
                return (EReference)naryRelationLinkEClass.getEStructuralFeatures().get(0);
        }
@@ -557,6 +599,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getNaryRelationLinkElement() {
                return naryRelationLinkElementEClass;
        }
@@ -566,6 +609,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EAttribute getNaryRelationLinkElement_Index() {
                return (EAttribute)naryRelationLinkElementEClass.getEStructuralFeatures().get(0);
        }
@@ -575,6 +619,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getNaryRelationLinkElement_Param() {
                return (EReference)naryRelationLinkElementEClass.getEStructuralFeatures().get(1);
        }
@@ -584,6 +629,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getPrimitiveElement() {
                return primitiveElementEClass;
        }
@@ -593,6 +639,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EAttribute getPrimitiveElement_ValueSet() {
                return (EAttribute)primitiveElementEClass.getEStructuralFeatures().get(0);
        }
@@ -602,6 +649,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getBooleanElement() {
                return booleanElementEClass;
        }
@@ -611,6 +659,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EAttribute getBooleanElement_Value() {
                return (EAttribute)booleanElementEClass.getEStructuralFeatures().get(0);
        }
@@ -620,6 +669,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getIntegerElement() {
                return integerElementEClass;
        }
@@ -629,6 +679,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EAttribute getIntegerElement_Value() {
                return (EAttribute)integerElementEClass.getEStructuralFeatures().get(0);
        }
@@ -638,6 +689,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getRealElement() {
                return realElementEClass;
        }
@@ -647,6 +699,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EAttribute getRealElement_Value() {
                return (EAttribute)realElementEClass.getEStructuralFeatures().get(0);
        }
@@ -656,6 +709,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getStringElement() {
                return stringElementEClass;
        }
@@ -665,6 +719,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EAttribute getStringElement_Value() {
                return (EAttribute)stringElementEClass.getEStructuralFeatures().get(0);
        }
@@ -674,6 +729,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getScope() {
                return scopeEClass;
        }
@@ -683,6 +739,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EAttribute getScope_MinNewElements() {
                return (EAttribute)scopeEClass.getEStructuralFeatures().get(0);
        }
@@ -692,6 +749,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EAttribute getScope_MaxNewElements() {
                return (EAttribute)scopeEClass.getEStructuralFeatures().get(1);
        }
@@ -701,6 +759,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getScope_TargetTypeInterpretation() {
                return (EReference)scopeEClass.getEStructuralFeatures().get(2);
        }
@@ -710,6 +769,17 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
+        public EAttribute getScope_MinNewElementsHeuristic() {
+                return (EAttribute)scopeEClass.getEStructuralFeatures().get(3);
+        }
+        /**
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        @Override
        public EClass getPartialPrimitiveInterpretation() {
                return partialPrimitiveInterpretationEClass;
        }
@@ -719,6 +789,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getPartialBooleanInterpretation() {
                return partialBooleanInterpretationEClass;
        }
@@ -728,6 +799,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getPartialIntegerInterpretation() {
                return partialIntegerInterpretationEClass;
        }
@@ -737,6 +809,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getPartialRealInterpretation() {
                return partialRealInterpretationEClass;
        }
@@ -746,6 +819,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getPartialStringInterpretation() {
                return partialStringInterpretationEClass;
        }
@@ -755,6 +829,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EClass getPartialComplexTypeInterpretation() {
                return partialComplexTypeInterpretationEClass;
        }
@@ -764,6 +839,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialComplexTypeInterpretation_SupertypeInterpretation() {
                return (EReference)partialComplexTypeInterpretationEClass.getEStructuralFeatures().get(0);
        }
@@ -773,6 +849,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public EReference getPartialComplexTypeInterpretation_InterpretationOf() {
                return (EReference)partialComplexTypeInterpretationEClass.getEStructuralFeatures().get(1);
        }
@@ -782,6 +859,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public PartialinterpretationFactory getPartialinterpretationFactory() {
                return (PartialinterpretationFactory)getEFactoryInstance();
        }
@@ -817,6 +895,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
                createEReference(partialInterpretationEClass, PARTIAL_INTERPRETATION__SCOPES);
                createEAttribute(partialInterpretationEClass, PARTIAL_INTERPRETATION__MIN_NEW_ELEMENTS);
                createEAttribute(partialInterpretationEClass, PARTIAL_INTERPRETATION__MAX_NEW_ELEMENTS);
+                createEAttribute(partialInterpretationEClass, PARTIAL_INTERPRETATION__MIN_NEW_ELEMENTS_HEURISTIC);
                partialConstantInterpretationEClass = createEClass(PARTIAL_CONSTANT_INTERPRETATION);
                createEReference(partialConstantInterpretationEClass, PARTIAL_CONSTANT_INTERPRETATION__INTERPRETATION_OF);
@@ -869,6 +948,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
                createEAttribute(scopeEClass, SCOPE__MIN_NEW_ELEMENTS);
                createEAttribute(scopeEClass, SCOPE__MAX_NEW_ELEMENTS);
                createEReference(scopeEClass, SCOPE__TARGET_TYPE_INTERPRETATION);
+                createEAttribute(scopeEClass, SCOPE__MIN_NEW_ELEMENTS_HEURISTIC);
                partialPrimitiveInterpretationEClass = createEClass(PARTIAL_PRIMITIVE_INTERPRETATION);
@@ -945,6 +1025,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
                initEReference(getPartialInterpretation_Scopes(), this.getScope(), null, "scopes", null, 0, -1, PartialInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
                initEAttribute(getPartialInterpretation_MinNewElements(), ecorePackage.getEInt(), "minNewElements", "0", 1, 1, PartialInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
                initEAttribute(getPartialInterpretation_MaxNewElements(), ecorePackage.getEInt(), "maxNewElements", "-1", 1, 1, PartialInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+                initEAttribute(getPartialInterpretation_MinNewElementsHeuristic(), ecorePackage.getEInt(), "minNewElementsHeuristic", "0", 1, 1, PartialInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
                initEClass(partialConstantInterpretationEClass, PartialConstantInterpretation.class, "PartialConstantInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
                initEReference(getPartialConstantInterpretation_InterpretationOf(), theLogiclanguagePackage.getConstantDeclaration(), null, "interpretationOf", null, 1, 1, PartialConstantInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
@@ -997,6 +1078,7 @@ public class PartialinterpretationPackageImpl extends EPackageImpl implements Pa
                initEAttribute(getScope_MinNewElements(), ecorePackage.getEInt(), "minNewElements", "0", 1, 1, Scope.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
                initEAttribute(getScope_MaxNewElements(), ecorePackage.getEInt(), "maxNewElements", "-1", 1, 1, Scope.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
                initEReference(getScope_TargetTypeInterpretation(), this.getPartialTypeInterpratation(), this.getPartialTypeInterpratation_Scopes(), "targetTypeInterpretation", null, 1, 1, Scope.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+                initEAttribute(getScope_MinNewElementsHeuristic(), ecorePackage.getEInt(), "minNewElementsHeuristic", "0", 1, 1, Scope.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
                initEClass(partialPrimitiveInterpretationEClass, PartialPrimitiveInterpretation.class, "PartialPrimitiveInterpretation", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PrimitiveElementImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PrimitiveElementImpl.java
index 29a1e1be..a8ef81b0 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PrimitiveElementImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/PrimitiveElementImpl.java
@@ -71,6 +71,7 @@ public abstract class PrimitiveElementImpl extends DefinedElementImpl implements
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public boolean isValueSet() {
                return valueSet;
        }
@@ -80,6 +81,7 @@ public abstract class PrimitiveElementImpl extends DefinedElementImpl implements
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setValueSet(boolean newValueSet) {
                boolean oldValueSet = valueSet;
                valueSet = newValueSet;
@@ -154,7 +156,7 @@ public abstract class PrimitiveElementImpl extends DefinedElementImpl implements
        public String toString() {
                if (eIsProxy()) return super.toString();
-                StringBuffer result = new StringBuffer(super.toString());
+                StringBuilder result = new StringBuilder(super.toString());
                result.append(" (valueSet: ");
                result.append(valueSet);
                result.append(')');
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/RealElementImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/RealElementImpl.java
index 0361a3e9..67cff5a2 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/RealElementImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/RealElementImpl.java
@@ -71,6 +71,7 @@ public class RealElementImpl extends PrimitiveElementImpl implements RealElement
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public BigDecimal getValue() {
                return value;
        }
@@ -80,6 +81,7 @@ public class RealElementImpl extends PrimitiveElementImpl implements RealElement
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setValue(BigDecimal newValue) {
                BigDecimal oldValue = value;
                value = newValue;
@@ -154,7 +156,7 @@ public class RealElementImpl extends PrimitiveElementImpl implements RealElement
        public String toString() {
                if (eIsProxy()) return super.toString();
-                StringBuffer result = new StringBuffer(super.toString());
+                StringBuilder result = new StringBuilder(super.toString());
                result.append(" (value: ");
                result.append(value);
                result.append(')');
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/ScopeImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/ScopeImpl.java
index d8ade871..a1b6de35 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/ScopeImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/ScopeImpl.java
@@ -26,6 +26,7 @@ import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
 *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.ScopeImpl#getMinNewElements <em>Min New Elements</em>}</li>
 *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.ScopeImpl#getMaxNewElements <em>Max New Elements</em>}</li>
 *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.ScopeImpl#getTargetTypeInterpretation <em>Target Type Interpretation</em>}</li>
+ *   <li>{@link hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.impl.ScopeImpl#getMinNewElementsHeuristic <em>Min New Elements Heuristic</em>}</li>
 * </ul>
 *
 * @generated
@@ -82,6 +83,26 @@ public class ScopeImpl extends MinimalEObjectImpl.Container implements Scope {
        protected PartialTypeInterpratation targetTypeInterpretation;
        /**
+         * The default value of the '{@link #getMinNewElementsHeuristic() <em>Min New Elements Heuristic</em>}' attribute.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @see #getMinNewElementsHeuristic()
+         * @generated
+         * @ordered
+         */
+        protected static final int MIN_NEW_ELEMENTS_HEURISTIC_EDEFAULT = 0;
+        /**
+         * The cached value of the '{@link #getMinNewElementsHeuristic() <em>Min New Elements Heuristic</em>}' attribute.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @see #getMinNewElementsHeuristic()
+         * @generated
+         * @ordered
+         */
+        protected int minNewElementsHeuristic = MIN_NEW_ELEMENTS_HEURISTIC_EDEFAULT;
+        /**
         * <!-- begin-user-doc -->
         * <!-- end-user-doc -->
         * @generated
@@ -105,6 +126,7 @@ public class ScopeImpl extends MinimalEObjectImpl.Container implements Scope {
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public int getMinNewElements() {
                return minNewElements;
        }
@@ -114,6 +136,7 @@ public class ScopeImpl extends MinimalEObjectImpl.Container implements Scope {
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setMinNewElements(int newMinNewElements) {
                int oldMinNewElements = minNewElements;
                minNewElements = newMinNewElements;
@@ -126,6 +149,7 @@ public class ScopeImpl extends MinimalEObjectImpl.Container implements Scope {
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public int getMaxNewElements() {
                return maxNewElements;
        }
@@ -135,6 +159,7 @@ public class ScopeImpl extends MinimalEObjectImpl.Container implements Scope {
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setMaxNewElements(int newMaxNewElements) {
                int oldMaxNewElements = maxNewElements;
                maxNewElements = newMaxNewElements;
@@ -147,6 +172,7 @@ public class ScopeImpl extends MinimalEObjectImpl.Container implements Scope {
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public PartialTypeInterpratation getTargetTypeInterpretation() {
                if (targetTypeInterpretation != null && targetTypeInterpretation.eIsProxy()) {
                        InternalEObject oldTargetTypeInterpretation = (InternalEObject)targetTypeInterpretation;
@@ -188,6 +214,7 @@ public class ScopeImpl extends MinimalEObjectImpl.Container implements Scope {
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setTargetTypeInterpretation(PartialTypeInterpratation newTargetTypeInterpretation) {
                if (newTargetTypeInterpretation != targetTypeInterpretation) {
                        NotificationChain msgs = null;
@@ -208,6 +235,29 @@ public class ScopeImpl extends MinimalEObjectImpl.Container implements Scope {
         * @generated
         */
        @Override
+        public int getMinNewElementsHeuristic() {
+                return minNewElementsHeuristic;
+        }
+        /**
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        @Override
+        public void setMinNewElementsHeuristic(int newMinNewElementsHeuristic) {
+                int oldMinNewElementsHeuristic = minNewElementsHeuristic;
+                minNewElementsHeuristic = newMinNewElementsHeuristic;
+                if (eNotificationRequired())
+                        eNotify(new ENotificationImpl(this, Notification.SET, PartialinterpretationPackage.SCOPE__MIN_NEW_ELEMENTS_HEURISTIC, oldMinNewElementsHeuristic, minNewElementsHeuristic));
+        }
+        /**
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         */
+        @Override
        public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
                switch (featureID) {
                        case PartialinterpretationPackage.SCOPE__TARGET_TYPE_INTERPRETATION:
@@ -247,6 +297,8 @@ public class ScopeImpl extends MinimalEObjectImpl.Container implements Scope {
                        case PartialinterpretationPackage.SCOPE__TARGET_TYPE_INTERPRETATION:
                                if (resolve) return getTargetTypeInterpretation();
                                return basicGetTargetTypeInterpretation();
+                        case PartialinterpretationPackage.SCOPE__MIN_NEW_ELEMENTS_HEURISTIC:
+                                return getMinNewElementsHeuristic();
                }
                return super.eGet(featureID, resolve, coreType);
        }
@@ -268,6 +320,9 @@ public class ScopeImpl extends MinimalEObjectImpl.Container implements Scope {
                        case PartialinterpretationPackage.SCOPE__TARGET_TYPE_INTERPRETATION:
                                setTargetTypeInterpretation((PartialTypeInterpratation)newValue);
                                return;
+                        case PartialinterpretationPackage.SCOPE__MIN_NEW_ELEMENTS_HEURISTIC:
+                                setMinNewElementsHeuristic((Integer)newValue);
+                                return;
                }
                super.eSet(featureID, newValue);
        }
@@ -289,6 +344,9 @@ public class ScopeImpl extends MinimalEObjectImpl.Container implements Scope {
                        case PartialinterpretationPackage.SCOPE__TARGET_TYPE_INTERPRETATION:
                                setTargetTypeInterpretation((PartialTypeInterpratation)null);
                                return;
+                        case PartialinterpretationPackage.SCOPE__MIN_NEW_ELEMENTS_HEURISTIC:
+                                setMinNewElementsHeuristic(MIN_NEW_ELEMENTS_HEURISTIC_EDEFAULT);
+                                return;
                }
                super.eUnset(featureID);
        }
@@ -307,6 +365,8 @@ public class ScopeImpl extends MinimalEObjectImpl.Container implements Scope {
                                return maxNewElements != MAX_NEW_ELEMENTS_EDEFAULT;
                        case PartialinterpretationPackage.SCOPE__TARGET_TYPE_INTERPRETATION:
                                return targetTypeInterpretation != null;
+                        case PartialinterpretationPackage.SCOPE__MIN_NEW_ELEMENTS_HEURISTIC:
+                                return minNewElementsHeuristic != MIN_NEW_ELEMENTS_HEURISTIC_EDEFAULT;
                }
                return super.eIsSet(featureID);
        }
@@ -320,11 +380,13 @@ public class ScopeImpl extends MinimalEObjectImpl.Container implements Scope {
        public String toString() {
                if (eIsProxy()) return super.toString();
-                StringBuffer result = new StringBuffer(super.toString());
+                StringBuilder result = new StringBuilder(super.toString());
                result.append(" (minNewElements: ");
                result.append(minNewElements);
                result.append(", maxNewElements: ");
                result.append(maxNewElements);
+                result.append(", minNewElementsHeuristic: ");
+                result.append(minNewElementsHeuristic);
                result.append(')');
                return result.toString();
        }
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/StringElementImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/StringElementImpl.java
index f207401d..0242c9b2 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/StringElementImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/StringElementImpl.java
@@ -69,6 +69,7 @@ public class StringElementImpl extends PrimitiveElementImpl implements StringEle
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public String getValue() {
                return value;
        }
@@ -78,6 +79,7 @@ public class StringElementImpl extends PrimitiveElementImpl implements StringEle
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setValue(String newValue) {
                String oldValue = value;
                value = newValue;
@@ -152,7 +154,7 @@ public class StringElementImpl extends PrimitiveElementImpl implements StringEle
        public String toString() {
                if (eIsProxy()) return super.toString();
-                StringBuffer result = new StringBuffer(super.toString());
+                StringBuilder result = new StringBuilder(super.toString());
                result.append(" (value: ");
                result.append(value);
                result.append(')');
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/UnaryElementRelationLinkImpl.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/UnaryElementRelationLinkImpl.java
index 2cb56323..e76a89b7 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/UnaryElementRelationLinkImpl.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/ecore-gen/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/partialinterpretation/impl/UnaryElementRelationLinkImpl.java
@@ -62,6 +62,7 @@ public class UnaryElementRelationLinkImpl extends RelationLinkImpl implements Un
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public DefinedElement getParam1() {
                if (param1 != null && param1.eIsProxy()) {
                        InternalEObject oldParam1 = (InternalEObject)param1;
@@ -88,6 +89,7 @@ public class UnaryElementRelationLinkImpl extends RelationLinkImpl implements Un
         * <!-- end-user-doc -->
         * @generated
         */
+        @Override
        public void setParam1(DefinedElement newParam1) {
                DefinedElement oldParam1 = param1;
                param1 = newParam1;
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/model/PartialInterpretation.ecore b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/model/PartialInterpretation.ecore
index acf82a3f..47d54258 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/model/PartialInterpretation.ecore
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/model/PartialInterpretation.ecore
@@ -27,6 +27,9 @@
        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt" defaultValueLiteral="0"/>
    <eStructuralFeatures xsi:type="ecore:EAttribute" name="maxNewElements" lowerBound="1"
        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt" defaultValueLiteral="-1"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="minNewElementsHeuristic"
+        lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"
+        defaultValueLiteral="0"/>
  </eClassifiers>
  <eClassifiers xsi:type="ecore:EClass" name="PartialConstantInterpretation">
    <eStructuralFeatures xsi:type="ecore:EReference" name="interpretationOf" lowerBound="1"
@@ -92,6 +95,9 @@
        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt" defaultValueLiteral="-1"/>
    <eStructuralFeatures xsi:type="ecore:EReference" name="targetTypeInterpretation"
        lowerBound="1" eType="#//PartialTypeInterpratation" eOpposite="#//PartialTypeInterpratation/scopes"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="minNewElementsHeuristic"
+        lowerBound="1" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"
+        defaultValueLiteral="0"/>
  </eClassifiers>
  <eClassifiers xsi:type="ecore:EClass" name="PartialPrimitiveInterpretation" abstract="true"
      eSuperTypes="#//PartialTypeInterpratation"/>
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/model/PartialInterpretation.genmodel b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/model/PartialInterpretation.genmodel
index 2ac0a4f3..daeaf594 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/model/PartialInterpretation.genmodel
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/model/PartialInterpretation.genmodel
@@ -18,7 +18,10 @@
      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//PartialInterpretation/partialtypeinterpratation"/>
      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//PartialInterpretation/openWorldElements"/>
      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//PartialInterpretation/problemConainer"/>
-      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//PartialInterpretation/scope"/>
+      <genFeatures property="None" children="true" createChild="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//PartialInterpretation/scopes"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute PartialInterpretation.ecore#//PartialInterpretation/minNewElements"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute PartialInterpretation.ecore#//PartialInterpretation/maxNewElements"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute PartialInterpretation.ecore#//PartialInterpretation/minNewElementsHeuristic"/>
    </genClasses>
    <genClasses ecoreClass="PartialInterpretation.ecore#//PartialConstantInterpretation">
      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//PartialConstantInterpretation/interpretationOf"/>
@@ -33,9 +36,8 @@
      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//PartialFunctionInterpretation/interpretationOf"/>
    </genClasses>
    <genClasses ecoreClass="PartialInterpretation.ecore#//PartialTypeInterpratation">
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//PartialTypeInterpratation/interpretationOf"/>
      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//PartialTypeInterpratation/elements"/>
-      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//PartialTypeInterpratation/supertypeInterpretation"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//PartialTypeInterpratation/scopes"/>
    </genClasses>
    <genClasses image="false" ecoreClass="PartialInterpretation.ecore#//RelationLink"/>
    <genClasses ecoreClass="PartialInterpretation.ecore#//UnaryElementRelationLink">
@@ -50,6 +52,7 @@
    </genClasses>
    <genClasses ecoreClass="PartialInterpretation.ecore#//NaryRelationLinkElement">
      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute PartialInterpretation.ecore#//NaryRelationLinkElement/index"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//NaryRelationLinkElement/param"/>
    </genClasses>
    <genClasses image="false" ecoreClass="PartialInterpretation.ecore#//PrimitiveElement">
      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute PartialInterpretation.ecore#//PrimitiveElement/valueSet"/>
@@ -70,11 +73,16 @@
      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute PartialInterpretation.ecore#//Scope/minNewElements"/>
      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute PartialInterpretation.ecore#//Scope/maxNewElements"/>
      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//Scope/targetTypeInterpretation"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute PartialInterpretation.ecore#//Scope/minNewElementsHeuristic"/>
    </genClasses>
    <genClasses image="false" ecoreClass="PartialInterpretation.ecore#//PartialPrimitiveInterpretation"/>
    <genClasses ecoreClass="PartialInterpretation.ecore#//PartialBooleanInterpretation"/>
    <genClasses ecoreClass="PartialInterpretation.ecore#//PartialIntegerInterpretation"/>
    <genClasses ecoreClass="PartialInterpretation.ecore#//PartialRealInterpretation"/>
    <genClasses ecoreClass="PartialInterpretation.ecore#//PartialStringInterpretation"/>
+    <genClasses ecoreClass="PartialInterpretation.ecore#//PartialComplexTypeInterpretation">
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//PartialComplexTypeInterpretation/supertypeInterpretation"/>
+      <genFeatures notify="false" createChild="false" propertySortChoices="true" ecoreFeature="ecore:EReference PartialInterpretation.ecore#//PartialComplexTypeInterpretation/interpretationOf"/>
+    </genClasses>
  </genPackages>
 </genmodel:GenModel>
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend
index 8aaaacb5..cb5b587f 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend
@@ -1,5 +1,6 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic
+import com.google.common.collect.ImmutableList
 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic
 import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput
@@ -12,18 +13,18 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.Par
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.Problem2PartialInterpretationTrace
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationFactory
+import java.math.BigDecimal
 import java.util.HashMap
+import java.util.HashSet
 import java.util.List
 import java.util.Map
+import java.util.Set
 import org.eclipse.emf.common.util.Enumerator
+import org.eclipse.emf.ecore.EAttribute
 import org.eclipse.emf.ecore.EObject
 import org.eclipse.emf.ecore.resource.Resource
 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
-import java.util.HashSet
-import java.util.Set
-import java.math.BigDecimal
-import org.eclipse.emf.ecore.EAttribute
 class InstanceModel2PartialInterpretation {
        val extension LogiclanguageFactory factory = LogiclanguageFactory.eINSTANCE
@@ -36,7 +37,19 @@ class InstanceModel2PartialInterpretation {
                Resource resource,
                boolean withID) 
        {
-                val objects = resource.allContents.toList
+                val objectsBuilder = ImmutableList.builder
+                val treeIterator = resource.allContents
+                val referencesUsed = ecore2Logic.allReferencesInScope(metamodelTranslationResult.trace).toSet
+                while (treeIterator.hasNext) {
+                        val object = treeIterator.next
+                        val containingReference = object.eContainmentFeature
+                        if (containingReference === null || referencesUsed.contains(containingReference)) {
+                                objectsBuilder.add(object)
+                        } else {
+                                treeIterator.prune
+                        }
+                }
+                val objects = objectsBuilder.build
                return transform(metamodelTranslationResult,objects,withID)
        }
        
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/META-INF/MANIFEST.MF b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/META-INF/MANIFEST.MF
index 2a271acf..4ad61ccb 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/META-INF/MANIFEST.MF
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/META-INF/MANIFEST.MF
@@ -3,7 +3,8 @@ Bundle-ManifestVersion: 2
 Bundle-Name: Reasoner
 Bundle-SymbolicName: hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner
 Bundle-Version: 1.0.0.qualifier
-Export-Package: hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner
+Export-Package: hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
 Require-Bundle: hu.bme.mit.inf.dslreasoner.ecore2logic;bundle-version="1.0.0",
 hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0",
 hu.bme.mit.inf.dslreasoner.viatra2logic;bundle-version="1.0.0",
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ModelGenerationMethodBasedGlobalConstraint.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ModelGenerationMethodBasedGlobalConstraint.xtend
index 28cf986d..9ef5e091 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ModelGenerationMethodBasedGlobalConstraint.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ModelGenerationMethodBasedGlobalConstraint.xtend
@@ -1,11 +1,11 @@
-package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner
-import org.eclipse.viatra.dse.objectives.IGlobalConstraint
+import org.eclipse.viatra.dse.objectives.IGlobalConstraint
-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationMethod
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationMethod
-abstract class ModelGenerationMethodBasedGlobalConstraint implements IGlobalConstraint {
+abstract class ModelGenerationMethodBasedGlobalConstraint implements IGlobalConstraint {
-        val protected ModelGenerationMethod method
+        val protected ModelGenerationMethod method
-        new(ModelGenerationMethod method) {
+        new(ModelGenerationMethod method) {
-                this.method = method
+                this.method = method
-        }
+        }
-}
-\ No newline at end of file
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasoner.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasoner.xtend
index 0411ccdd..3033eca7 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasoner.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasoner.xtend
@@ -1,5 +1,7 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.Lists
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.DocumentationLevel
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasoner
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasonerException
@@ -10,19 +12,28 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage
 import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicresultFactory
 import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.ModelResult
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationMethodProvider
-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ScopePropagator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagatorStrategy
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.PartialInterpretationInitialiser
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder.AbstractNeighbourhoodBasedStateCoderFactory
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder.IdentifierBasedStateCoderFactory
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder.NeighbourhoodBasedStateCoderFactory
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder.NeighbourhoodBasedHashStateCoderFactory
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder.PairwiseNeighbourhoodBasedStateCoderFactory
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.BasicScopeGlobalConstraint
 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.BestFirstStrategyForModelGeneration
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.DiversityChecker
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.InconsistentScopeGlobalConstraint
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.LoggerSolutionFoundHandler
 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.ModelGenerationCompositeObjective
 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.PartialModelAsLogicInterpretation
 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.ScopeObjective
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.SurelyViolatedObjectiveGlobalConstraint
 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.UnfinishedMultiplicityObjective
-import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.UnfinishedWFObjective
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.ViatraReasonerSolutionSaver
 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.WF2ObjectiveConverter
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ThreeValuedCostElement
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ThreeValuedCostObjective
 import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace
 import java.util.List
 import java.util.Map
@@ -31,114 +42,159 @@ import org.eclipse.viatra.dse.api.DesignSpaceExplorer
 import org.eclipse.viatra.dse.api.DesignSpaceExplorer.DseLoggingLevel
 import org.eclipse.viatra.dse.solutionstore.SolutionStore
 import org.eclipse.viatra.dse.statecode.IStateCoderFactory
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.NumericSolver
-class ViatraReasoner extends LogicReasoner{
+class ViatraReasoner extends LogicReasoner {
        val PartialInterpretationInitialiser initialiser = new PartialInterpretationInitialiser()
        val ModelGenerationMethodProvider modelGenerationMethodProvider = new ModelGenerationMethodProvider
-        val extension LogicresultFactory factory = LogicresultFactory.eINSTANCE 
+        val extension LogicresultFactory factory = LogicresultFactory.eINSTANCE
        val WF2ObjectiveConverter wf2ObjectiveConverter = new WF2ObjectiveConverter
-        
-        
+        override solve(LogicProblem problem, LogicSolverConfiguration configuration,
-        override solve(LogicProblem problem, LogicSolverConfiguration configuration, ReasonerWorkspace workspace) throws LogicReasonerException {
+                ReasonerWorkspace workspace) throws LogicReasonerException {
                val viatraConfig = configuration.asConfig
-                
-                if(viatraConfig.debugCongiguration.logging) {
+                if (viatraConfig.documentationLevel == DocumentationLevel.FULL) {
                        DesignSpaceExplorer.turnOnLogging(DseLoggingLevel.VERBOSE_FULL)
                } else {
                        DesignSpaceExplorer.turnOnLogging(DseLoggingLevel.WARN)
                }
-                
                val DesignSpaceExplorer dse = new DesignSpaceExplorer();
-                
                dse.addMetaModelPackage(LogiclanguagePackage.eINSTANCE)
                dse.addMetaModelPackage(LogicproblemPackage.eINSTANCE)
                dse.addMetaModelPackage(PartialinterpretationPackage.eINSTANCE)
-                
                val transformationStartTime = System.nanoTime
-                
+                val emptySolution = initialiser.initialisePartialInterpretation(problem, viatraConfig.typeScopes).output
-                
+                if ((viatraConfig.documentationLevel == DocumentationLevel::FULL ||
-                val emptySolution = initialiser.initialisePartialInterpretation(problem,viatraConfig.typeScopes).output
+                        viatraConfig.documentationLevel == DocumentationLevel::NORMAL) && workspace !== null) {
-                if((viatraConfig.documentationLevel == DocumentationLevel::FULL || viatraConfig.documentationLevel == DocumentationLevel::NORMAL) && workspace !== null) {
+                        workspace.writeModel(emptySolution, "init.partialmodel")
-                        workspace.writeModel(emptySolution,"init.partialmodel")
+                }
-                } 
                emptySolution.problemConainer = problem
-                
+                var BasicScopeGlobalConstraint basicScopeGlobalConstraint = null
-                val ScopePropagator scopePropagator = new ScopePropagator(emptySolution)
+                if (viatraConfig.scopePropagatorStrategy == ScopePropagatorStrategy.None) {
-                scopePropagator.propagateAllScopeConstraints            
+                        basicScopeGlobalConstraint = new BasicScopeGlobalConstraint(emptySolution)
-                
+                        emptySolution.scopes.clear
+                }
                val method = modelGenerationMethodProvider.createModelGenerationMethod(
                        problem,
                        emptySolution,
                        workspace,
                        viatraConfig.nameNewElements,
                        viatraConfig.typeInferenceMethod,
-                        scopePropagator,
+                        viatraConfig.scopePropagatorStrategy,
-                        viatraConfig.documentationLevel,
+                        viatraConfig.hints,
-                        viatraConfig.calculateObjectCreationCosts
+                        viatraConfig.documentationLevel
                )
-                //println("parsed")
-                
                dse.addObjective(new ModelGenerationCompositeObjective(
-                        new ScopeObjective,
+                        basicScopeGlobalConstraint ?: new ScopeObjective,
                        method.unfinishedMultiplicities.map[new UnfinishedMultiplicityObjective(it)],
-                        new UnfinishedWFObjective(method.unfinishedWF),
+                        wf2ObjectiveConverter.createCompletenessObjective(method.unfinishedWF),
                        viatraConfig
                ))
-                dse.addGlobalConstraint(wf2ObjectiveConverter.createInvalidationObjective(method.invalidWF))
+                val extremalObjectives = Lists.newArrayListWithExpectedSize(viatraConfig.costObjectives.size)
-                for(additionalConstraint : viatraConfig.searchSpaceConstraints.additionalGlobalConstraints) {
+                for (entry : viatraConfig.costObjectives.indexed) {
+                        val objectiveName = '''costObjective«entry.key»'''
+                        val objectiveConfig = entry.value
+                        val elementsBuilder = ImmutableList.builder
+                        for (elementConfig : objectiveConfig.elements) {
+                                val relationName = elementConfig.patternQualifiedName
+                                val modalQueries = method.modalRelationQueries.get(relationName)
+                                if (modalQueries === null) {
+                                        throw new IllegalArgumentException("Unknown relation: " + relationName)
+                                }
+                                elementsBuilder.add(new ThreeValuedCostElement(
+                                        modalQueries.currentQuery,
+                                        modalQueries.mayQuery,
+                                        modalQueries.mustQuery,
+                                        elementConfig.weight
+                                ))
+                        }
+                        val costElements = elementsBuilder.build
+                        val costObjective = new ThreeValuedCostObjective(objectiveName, costElements, objectiveConfig.kind,
+                                objectiveConfig.threshold, 3)
+                        dse.addObjective(costObjective)
+                        if (objectiveConfig.findExtremum) {
+                                extremalObjectives += costObjective
+                        }
+                }
+                val numberOfRequiredSolutions = configuration.solutionScope.numberOfRequiredSolutions
+                val solutionStore = if (extremalObjectives.empty) {
+                                new SolutionStore(numberOfRequiredSolutions)
+                        } else {
+                                new SolutionStore()
+                        }
+                solutionStore.registerSolutionFoundHandler(new LoggerSolutionFoundHandler(viatraConfig))
+                val diversityChecker = DiversityChecker.of(viatraConfig.diversityRequirement)
+                val numericSolver = new NumericSolver(method, viatraConfig.runIntermediateNumericalConsistencyChecks, false)
+                val solutionSaver = new ViatraReasonerSolutionSaver(newArrayList(extremalObjectives), numberOfRequiredSolutions,
+                        diversityChecker, numericSolver)
+                val solutionCopier = solutionSaver.solutionCopier
+                solutionStore.withSolutionSaver(solutionSaver)
+                dse.solutionStore = solutionStore
+                dse.addGlobalConstraint(wf2ObjectiveConverter.createInvalidationGlobalConstraint(method.invalidWF))
+                dse.addGlobalConstraint(new SurelyViolatedObjectiveGlobalConstraint(solutionSaver))
+                dse.addGlobalConstraint(new InconsistentScopeGlobalConstraint)
+                if (basicScopeGlobalConstraint !== null) {
+                        dse.addGlobalConstraint(basicScopeGlobalConstraint)
+                }
+                for (additionalConstraint : viatraConfig.searchSpaceConstraints.additionalGlobalConstraints) {
                        dse.addGlobalConstraint(additionalConstraint.apply(method))
                }
-                
-                dse.setInitialModel(emptySolution,false)
+                dse.setInitialModel(emptySolution, false)
-                
-                val IStateCoderFactory statecoder = if(viatraConfig.stateCoderStrategy == StateCoderStrategy.Neighbourhood) {
+                val IStateCoderFactory statecoder = switch (viatraConfig.stateCoderStrategy) {
-                        new NeighbourhoodBasedStateCoderFactory
+                        case Neighbourhood:
-                } else {
+                                new NeighbourhoodBasedHashStateCoderFactory
-                        new IdentifierBasedStateCoderFactory
+                        case PairwiseNeighbourhood:
+                                new PairwiseNeighbourhoodBasedStateCoderFactory
+                        default:
+                                new IdentifierBasedStateCoderFactory
                }
                dse.stateCoderFactory = statecoder
-                
                dse.maxNumberOfThreads = 1
-                
-                val solutionStore =  new SolutionStore(configuration.solutionScope.numberOfRequiredSolution)
+                for (rule : method.relationRefinementRules) {
-                dse.solutionStore = solutionStore
-                
-                for(rule : method.relationRefinementRules) {
                        dse.addTransformationRule(rule)
                }
-                for(rule : method.objectRefinementRules) {
+                for (rule : method.objectRefinementRules) {
                        dse.addTransformationRule(rule)
                }
-                
-                val strategy = new BestFirstStrategyForModelGeneration(workspace,viatraConfig,method)
+                val strategy = new BestFirstStrategyForModelGeneration(workspace, viatraConfig, method, solutionSaver, numericSolver)
                viatraConfig.progressMonitor.workedForwardTransformation
-                val transformationFinished = System.nanoTime 
+                val transformationFinished = System.nanoTime
                val transformationTime = transformationFinished - transformationStartTime
-                
                val solverStartTime = System.nanoTime
-                
                var boolean stoppedByTimeout
-                var boolean stoppedByException
+                try {
-                try{
+                        stoppedByTimeout = dse.startExplorationWithTimeout(strategy, configuration.runtimeLimit * 1000);
-                        stoppedByTimeout = dse.startExplorationWithTimeout(strategy,configuration.runtimeLimit*1000);
-                        stoppedByException = false
                } catch (NullPointerException npe) {
                        stoppedByTimeout = false
-                        stoppedByException = true
                }
                val solverTime = System.nanoTime - solverStartTime
                viatraConfig.progressMonitor.workedSearchFinished
-                
-                //additionalMatches = strategy.solutionStoreWithCopy.additionalMatches
+                // additionalMatches = strategy.solutionStoreWithCopy.additionalMatches
                val statistics = createStatistics => [
-                        //it.solverTime = viatraConfig.runtimeLimit
+                        // it.solverTime = viatraConfig.runtimeLimit
-                        it.solverTime = (solverTime/1000000) as int
+                        it.solverTime = (solverTime / 1000000) as int
-                        it.transformationTime = (transformationTime/1000000) as int
+                        it.transformationTime = (transformationTime / 1000000) as int
-                        for(x : 0..<strategy.solutionStoreWithCopy.allRuntimes.size) {
+                        for (pair : solutionCopier.getAllCopierRuntimes(true).indexed) {
                                it.entries += createIntStatisticEntry => [
-                                        it.name = '''Solution«x+1»FoundAt'''
+                                        it.name = '''_Solution«pair.key»FoundAt'''
-                                        it.value = (strategy.solutionStoreWithCopy.allRuntimes.get(x)/1000000) as int
+                                        it.value = (pair.value / 1000000) as int
                                ]
                        }
                        for(x: 0..<strategy.times.size) {
@@ -151,16 +207,32 @@ class ViatraReasoner extends LogicReasoner{
                                it.name = "ExplorationInitializationTime" it.value = ((strategy.explorationStarted-transformationFinished)/1000000) as int
                        ]
                        it.entries += createIntStatisticEntry => [
-                                it.name = "TransformationExecutionTime" it.value = (method.statistics.transformationExecutionTime/1000000) as int
+                                it.name = "TransformationExecutionTime"
+                                it.value = (method.statistics.transformationExecutionTime / 1000000) as int
+                        ]
+                        it.entries += createIntStatisticEntry => [
+                                it.name = "ScopePropagationTime"
+                                it.value = (method.statistics.scopePropagationTime / 1000000) as int
                        ]
                        it.entries += createIntStatisticEntry => [
-                                it.name = "TypeAnalysisTime" it.value = (method.statistics.PreliminaryTypeAnalisisTime/1000000) as int
+                                it.name = "TypeAnalysisTime"
+                                it.value = (method.statistics.preliminaryTypeAnalisisTime / 1000000) as int
                        ]
                        it.entries += createIntStatisticEntry => [
-                                it.name = "StateCoderTime" it.value = (statecoder.runtime/1000000) as int
+                                it.name = "StateCoderTime"
+                                it.value = (statecoder.runtime / 1000000) as int
                        ]
                        it.entries += createIntStatisticEntry => [
-                                it.name = "StateCoderFailCount" it.value = strategy.numberOfStatecoderFail
+                                it.name = "StateCoderFailCount"
+                                it.value = strategy.numberOfStatecoderFail
+                        ]
+                        it.entries += createIntStatisticEntry => [
+                                it.name = "SolutionCopyTime"
+                                it.value = (solutionCopier.getTotalCopierRuntime / 1000000) as int
+                        ]
+                        it.entries += createIntStatisticEntry => [
+                                it.name = "States"
+                                it.value = dse.numberOfStates as int
                        ]
                        it.entries += createIntStatisticEntry => [
                                it.name = "ForwardTime" it.value = (strategy.forwardTime/1000000) as int
@@ -175,12 +247,28 @@ class ViatraReasoner extends LogicReasoner{
                                it.name = "FitnessCalculationTime" it.value = (strategy.fitnessCalculationTime/1000000) as int
                        ]
                        it.entries += createIntStatisticEntry => [
-                                it.name = "SolutionCopyTime" it.value = (strategy.solutionStoreWithCopy.sumRuntime/1000000) as int
+                                it.name = "SolutionCopyTime" it.value = (solutionSaver.totalCopierRuntime/1000000) as int
                        ]
                        it.entries += createIntStatisticEntry => [
                                it.name = "ActivationSelectionTime" it.value = (strategy.activationSelector.runtime/1000000) as int
                        ]
                        it.entries += createIntStatisticEntry => [
+                                it.name = "Decisions"
+                                it.value = method.statistics.decisionsTried
+                        ]
+                        it.entries += createIntStatisticEntry => [
+                                it.name = "Transformations"
+                                it.value = method.statistics.transformationInvocations
+                        ]
+                        it.entries += createIntStatisticEntry => [
+                                it.name = "ScopePropagations"
+                                it.value = method.statistics.scopePropagatorInvocations
+                        ]
+                        it.entries += createIntStatisticEntry => [
+                                it.name = "ScopePropagationsSolverCalls"
+                                it.value = method.statistics.scopePropagatorSolverInvocations
+                        ]
+                        it.entries += createIntStatisticEntry => [
                                it.name = "NumericalSolverSumTime" it.value = (strategy.numericSolver.runtime/1000000) as int
                        ]
                        it.entries += createIntStatisticEntry => [
@@ -201,61 +289,67 @@ class ViatraReasoner extends LogicReasoner{
                        it.entries += createIntStatisticEntry => [
                                it.name = "NumericalSolverCachedAnswerNumber" it.value = strategy.numericSolver.numberOfCachedSolverCalls
                        ]
-                        if(strategy.solutionStoreWithDiversityDescriptor.isActive) {
+                        if(diversityChecker.active) {
                                it.entries += createIntStatisticEntry => [
-                                        it.name = "SolutionDiversityCheckTime" it.value = (strategy.solutionStoreWithDiversityDescriptor.sumRuntime/1000000) as int
+                                        it.name = "SolutionDiversityCheckTime"
+                                        it.value = (diversityChecker.totalRuntime / 1000000) as int
                                ]
                                it.entries += createRealStatisticEntry => [
-                                        it.name = "SolutionDiversitySuccessRate" it.value = strategy.solutionStoreWithDiversityDescriptor.successRate
+                                        it.name = "SolutionDiversitySuccessRate"
+                                        it.value = diversityChecker.successRate
                                ]
                        }
                ]
-                
                viatraConfig.progressMonitor.workedBackwardTransformationFinished
-                
-                if(stoppedByTimeout) {
+                if (stoppedByTimeout) {
-                        return createInsuficientResourcesResult=>[
+                        return createInsuficientResourcesResult => [
                                it.problem = problem
-                                it.resourceName="time"
+                                it.resourceName = "time"
-                                it.representation += strategy.solutionStoreWithCopy.solutions
+                                it.representation += solutionCopier.getPartialInterpretations(true)
                                it.statistics = statistics
                        ]
                } else {
-                        if(solutionStore.solutions.empty) {
+                        if (solutionStore.solutions.empty) {
                                return createInconsistencyResult => [
                                        it.problem = problem
-                                        it.representation += strategy.solutionStoreWithCopy.solutions
+                                        it.representation += solutionCopier.getPartialInterpretations(true)
                                        it.statistics = statistics
                                ]
                        } else {
                                return createModelResult => [
                                        it.problem = problem
-                                        it.trace = strategy.solutionStoreWithCopy.copyTraces
+                                        it.trace = solutionCopier.getTraces(true)
-                                        it.representation += strategy.solutionStoreWithCopy.solutions
+                                        it.representation += solutionCopier.getPartialInterpretations(true)
                                        it.statistics = statistics
                                ]
                        }
                }
        }
-    private def dispatch long runtime(NeighbourhoodBasedStateCoderFactory sc) {
+        private def dispatch long runtime(AbstractNeighbourhoodBasedStateCoderFactory sc) {
-        sc.sumStatecoderRuntime
+                sc.sumStatecoderRuntime
-    }
+        }
-    private def dispatch long runtime(IdentifierBasedStateCoderFactory sc) {
+        private def dispatch long runtime(IdentifierBasedStateCoderFactory sc) {
-        sc.sumStatecoderRuntime
+                sc.sumStatecoderRuntime
-    }
+        }
        override getInterpretations(ModelResult modelResult) {
-                val indexes = 0..<modelResult.representation.size
+                val indexes = 0 ..< modelResult.representation.size
                val traces = modelResult.trace as List<Map<EObject, EObject>>;
-                val res = indexes.map[i | new PartialModelAsLogicInterpretation(modelResult.representation.get(i) as PartialInterpretation,traces.get(i))].toList
+                val res = indexes.map [ i |
+                        new PartialModelAsLogicInterpretation(modelResult.representation.get(i) as PartialInterpretation,
+                                traces.get(i))
+                ].toList
                return res
        }
-        
        private def ViatraReasonerConfiguration asConfig(LogicSolverConfiguration configuration) {
-                if(configuration instanceof ViatraReasonerConfiguration) {
+                if (configuration instanceof ViatraReasonerConfiguration) {
                        return configuration
-                } else throw new IllegalArgumentException('''Wrong configuration. Expected: «ViatraReasonerConfiguration.name», but got: «configuration.class.name»"''')
+                } else
+                        throw new IllegalArgumentException('''Wrong configuration. Expected: «ViatraReasonerConfiguration.name», but got: «configuration.class.name»"''')
        }
 }
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasonerConfiguration.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasonerConfiguration.xtend
index 6e3c5235..ddd25aac 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasonerConfiguration.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasonerConfiguration.xtend
@@ -6,19 +6,28 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationMethod
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedralScopePropagatorConstraints
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedralScopePropagatorSolver
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagatorStrategy
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualiser
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveKind
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveThreshold
 import java.util.LinkedList
 import java.util.List
 import java.util.Set
 import org.eclipse.xtext.xbase.lib.Functions.Function1
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearTypeConstraintHint
-public enum StateCoderStrategy {
+enum StateCoderStrategy {
-        Neighbourhood, NeighbourhoodWithEquivalence, IDBased, DefinedByDiversity
+        Neighbourhood,
+        PairwiseNeighbourhood,
+        NeighbourhoodWithEquivalence,
+        IDBased,
+        DefinedByDiversity
 }
-class ViatraReasonerConfiguration extends LogicSolverConfiguration{
+class ViatraReasonerConfiguration extends LogicSolverConfiguration {
-        //public var Iterable<PQuery> existingQueries
+        // public var Iterable<PQuery> existingQueries
-        
        public var nameNewElements = false
        public var StateCoderStrategy stateCoderStrategy = StateCoderStrategy.Neighbourhood
        public var TypeInferenceMethod typeInferenceMethod = TypeInferenceMethod.PreliminaryAnalysis
@@ -26,7 +35,7 @@ class ViatraReasonerConfiguration extends LogicSolverConfiguration{
         * Once per 1/randomBacktrackChance the search selects a random state.
         */
        public var int randomBacktrackChance = 20;
-        
        /**
         * Describes the required diversity between the solutions.
         * Null means that the solutions have to have different state codes only.
@@ -40,7 +49,7 @@ class ViatraReasonerConfiguration extends LogicSolverConfiguration{
        /**
         * Configuration for debugging support.
         */
-        public var DebugConfiguration debugCongiguration = new DebugConfiguration
+        public var DebugConfiguration debugConfiguration = new DebugConfiguration
        /**
         * Configuration for cutting search space.
         */
@@ -54,10 +63,15 @@ class ViatraReasonerConfiguration extends LogicSolverConfiguration{
        public var nonContainmentWeight = 1
        public var unfinishedWFWeight = 1
        
-        public var calculateObjectCreationCosts = false
+        public var ScopePropagatorStrategy scopePropagatorStrategy = new ScopePropagatorStrategy.Polyhedral(
+                PolyhedralScopePropagatorConstraints.Relational, PolyhedralScopePropagatorSolver.Clp)
+        
+        public var List<LinearTypeConstraintHint> hints = newArrayList
+        public var List<CostObjectiveConfiguration> costObjectives = newArrayList
 }
-public class DiversityDescriptor {
+class DiversityDescriptor {
        public var ensureDiversity = false
        public static val FixPointRange = -1
        public var int range = FixPointRange
@@ -67,20 +81,31 @@ public class DiversityDescriptor {
        public var Set<RelationDeclaration> relevantRelations = null
 }
-public class DebugConfiguration {
+class DebugConfiguration {
-        public var logging = false
+        public var PartialInterpretationVisualiser partialInterpretatioVisualiser = null
-        public var PartialInterpretationVisualiser partialInterpretatioVisualiser = null;
        public var partalInterpretationVisualisationFrequency = 1
 }
-public class InternalConsistencyCheckerConfiguration {
+class InternalConsistencyCheckerConfiguration {
        public var LogicReasoner internalIncosnsitencyDetector = null
        public var LogicSolverConfiguration internalInconsistencDetectorConfiguration = null
        public var incternalConsistencyCheckingFrequency = 1
 }
-public class SearchSpaceConstraint {
+class SearchSpaceConstraint {
        public static val UNLIMITED_MAXDEPTH = Integer.MAX_VALUE
        public var int maxDepth = UNLIMITED_MAXDEPTH
        public var List<Function1<ModelGenerationMethod, ModelGenerationMethodBasedGlobalConstraint>> additionalGlobalConstraints = new LinkedList
-}
-\ No newline at end of file
+}
+class CostObjectiveConfiguration {
+        public var List<CostObjectiveElementConfiguration> elements = newArrayList
+        public var ObjectiveKind kind
+        public var ObjectiveThreshold threshold
+        public var boolean findExtremum
+}
+class CostObjectiveElementConfiguration {
+        public var String patternQualifiedName
+        public var int weight
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BasicScopeGlobalConstraint.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BasicScopeGlobalConstraint.xtend
new file mode 100644
index 00000000..67f447ed
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BasicScopeGlobalConstraint.xtend
@@ -0,0 +1,103 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+import com.google.common.collect.ImmutableList
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation
+import java.util.Comparator
+import java.util.List
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.objectives.Comparators
+import org.eclipse.viatra.dse.objectives.IGlobalConstraint
+import org.eclipse.viatra.dse.objectives.IObjective
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+class BasicScopeGlobalConstraint implements IGlobalConstraint, IObjective {
+        val PartialInterpretation p
+        val List<ScopeAssertion> assertions
+        new(PartialInterpretation p) {
+                this.p = p
+                assertions = ImmutableList.copyOf(p.scopes.map [
+                        val currentSize = targetTypeInterpretation.elements.size
+                        val minElements = minNewElements + currentSize
+                        val maxElements = if (maxNewElements < 0) {
+                                -1
+                        } else {
+                                maxNewElements + currentSize
+                        }
+                        new ScopeAssertion(minElements, maxElements, targetTypeInterpretation)
+                ])
+        }
+        override init(ThreadContext context) {
+                if (context.model != p) {
+                        throw new IllegalArgumentException(
+                                "Partial model must be passed to the constructor of BasicScopeGlobalConstraint")
+                }
+        }
+        override checkGlobalConstraint(ThreadContext context) {
+                assertions.forall[upperBoundSatisfied]
+        }
+        override getFitness(ThreadContext context) {
+                var double fitness = p.minNewElements
+                for (assertion : assertions) {
+                        if (!assertion.lowerBoundSatisfied) {
+                                fitness += 1
+                        }
+                }
+                fitness
+        }
+        override satisifiesHardObjective(Double fitness) {
+                fitness <= 0.01
+        }
+        override BasicScopeGlobalConstraint createNew() {
+                this
+        }
+        override getName() {
+                class.name
+        }
+        override getComparator() {
+                Comparators.LOWER_IS_BETTER
+        }
+        override getLevel() {
+                2
+        }
+        override isHardObjective() {
+                true
+        }
+        override setComparator(Comparator<Double> comparator) {
+                throw new UnsupportedOperationException
+        }
+        override setLevel(int level) {
+                throw new UnsupportedOperationException
+        }
+        @FinalFieldsConstructor
+        private static class ScopeAssertion {
+                val int lowerBound
+                val int upperBound
+                val PartialTypeInterpratation typeDefinitions
+                private def getCount() {
+                        typeDefinitions.elements.size
+                }
+                private def isLowerBoundSatisfied() {
+                        count >= lowerBound
+                }
+                private def isUpperBoundSatisfied() {
+                        upperBound < 0 || count <= upperBound
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BestFirstStrategyForModelGeneration.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BestFirstStrategyForModelGeneration.java
index e3603af3..e529892c 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BestFirstStrategyForModelGeneration.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BestFirstStrategyForModelGeneration.java
@@ -9,34 +9,25 @@
 *******************************************************************************/
 package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse;
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Map;
 import java.util.PriorityQueue;
 import java.util.Random;
 import org.apache.log4j.Logger;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.viatra.dse.api.SolutionTrajectory;
 import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy;
 import org.eclipse.viatra.dse.base.ThreadContext;
 import org.eclipse.viatra.dse.objectives.Fitness;
 import org.eclipse.viatra.dse.objectives.ObjectiveComparatorHelper;
+import org.eclipse.viatra.dse.solutionstore.ISolutionFoundHandler;
 import org.eclipse.viatra.dse.solutionstore.SolutionStore;
-import org.eclipse.viatra.query.runtime.api.AdvancedViatraQueryEngine;
-import org.eclipse.viatra.query.runtime.api.IPatternMatch;
-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
-import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.DocumentationLevel;
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasoner;
@@ -44,7 +35,6 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem;
 import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.InconsistencyResult;
 import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicResult;
 import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.ModelResult;
-import hu.bme.mit.inf.dslreasoner.viatra2logic.NumericProblemSolver;
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationMethod;
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.PartialInterpretation2Logic;
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation;
@@ -83,14 +73,13 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
        // Running
        private PriorityQueue<TrajectoryWithFitness> trajectoiresToExplore;
        private SolutionStore solutionStore;
-        private SolutionStoreWithCopy solutionStoreWithCopy;
-        private SolutionStoreWithDiversityDescriptor solutionStoreWithDiversityDescriptor;
        private volatile boolean isInterrupted = false;
        private ModelResult modelResultByInternalSolver = null;
        private Random random = new Random();
        //private Collection<ViatraQueryMatcher<? extends IPatternMatch>> matchers;
        public ActivationSelector activationSelector = new EvenActivationSelector(random);
-        public NumericSolver numericSolver = null;
+        public ViatraReasonerSolutionSaver solutionSaver;
+        public NumericSolver numericSolver;
        // Statistics
        private int numberOfStatecoderFail = 0;
        private int numberOfPrintedModel = 0;
@@ -103,19 +92,17 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
        public BestFirstStrategyForModelGeneration(
                        ReasonerWorkspace workspace,
                        ViatraReasonerConfiguration configuration,
-                        ModelGenerationMethod method)
+                        ModelGenerationMethod method,
-        {
+                        ViatraReasonerSolutionSaver solutionSaver,
+                        NumericSolver numericSolver) {
                this.workspace = workspace;
                this.configuration = configuration;
                this.method = method;
+                this.solutionSaver = solutionSaver;
+                this.numericSolver = numericSolver;
+                //logger.setLevel(Level.DEBUG);
        }
        
-        public SolutionStoreWithCopy getSolutionStoreWithCopy() {
-                return solutionStoreWithCopy;
-        }
-        public SolutionStoreWithDiversityDescriptor getSolutionStoreWithDiversityDescriptor() {
-                return solutionStoreWithDiversityDescriptor;
-        }
        public int getNumberOfStatecoderFail() {
                return numberOfStatecoderFail;
        }
@@ -125,22 +112,35 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
        public long getBacktrackingTime() {
                return context.getDesignSpaceManager().getBacktrackingTime();
        }
-        //LinkedList<ViatraQueryMatcher<? extends IPatternMatch>> matchers;
        @Override
        public void initStrategy(ThreadContext context) {
                this.context = context;
                this.solutionStore = context.getGlobalContext().getSolutionStore();
+                solutionStore.registerSolutionFoundHandler(new ISolutionFoundHandler() {
+                        
+                        @Override
+                        public void solutionTriedToSave(ThreadContext context, SolutionTrajectory trajectory) {
+                                // Ignore.
+                        }
+                        
+                        @Override
+                        public void solutionFound(ThreadContext context, SolutionTrajectory trajectory) {
+                                configuration.progressMonitor.workedModelFound(configuration.solutionScope.numberOfRequiredSolutions);
+                                saveTimes();
+                                logger.debug("Found a solution.");
+                        }
+                });
+                numericSolver.init(context);
                
 //              ViatraQueryEngine engine = context.getQueryEngine();
-//              // TODO: visualisation
 //              matchers = new LinkedList<ViatraQueryMatcher<? extends IPatternMatch>>();
 //              for(IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> p : this.method.getAllPatterns()) {
 //                      //System.out.println(p.getSimpleName());
 //                      ViatraQueryMatcher<? extends IPatternMatch> matcher = p.getMatcher(engine);
 //                      matchers.add(matcher);
 //              }
-                this.solutionStoreWithCopy = new SolutionStoreWithCopy();
+                
-                this.solutionStoreWithDiversityDescriptor = new SolutionStoreWithDiversityDescriptor(configuration.diversityRequirement);
                final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper();
                this.comparator = new Comparator<TrajectoryWithFitness>() {
                        @Override
@@ -148,8 +148,6 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                                return objectiveComparatorHelper.compare(o2.fitness, o1.fitness);
                        }
                };
-                
-                this.numericSolver = new NumericSolver(context, method, this.configuration.runIntermediateNumericalConsistencyChecks, false);
                trajectoiresToExplore = new PriorityQueue<TrajectoryWithFitness>(11, comparator);
        }
@@ -176,14 +174,13 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                        return;
                }
                
-                final Fitness firstFittness = calculateFitness();
+                final Fitness firstFitness = calculateFitness();
-                checkForSolution(firstFittness);
+                checkForSolution(firstFitness);
                
                final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper();
                final Object[] firstTrajectory = context.getTrajectory().toArray(new Object[0]);
-                TrajectoryWithFitness currentTrajectoryWithFittness = new TrajectoryWithFitness(firstTrajectory, firstFittness);
+                TrajectoryWithFitness currentTrajectoryWithFitness = new TrajectoryWithFitness(firstTrajectory, firstFitness);
-                trajectoiresToExplore.add(currentTrajectoryWithFittness);
+                trajectoiresToExplore.add(currentTrajectoryWithFitness);
-                
                //if(configuration)
                visualiseCurrentState();
 //              for(ViatraQueryMatcher<? extends IPatternMatch> matcher : matchers) {
@@ -197,22 +194,22 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                
                mainLoop: while (!isInterrupted && !configuration.progressMonitor.isCancelled()) {
-                        if (currentTrajectoryWithFittness == null) {
+                        if (currentTrajectoryWithFitness == null) {
                                if (trajectoiresToExplore.isEmpty()) {
                                        logger.debug("State space is fully traversed.");
                                        return;
                                } else {
-                                        currentTrajectoryWithFittness = selectState();
+                                        currentTrajectoryWithFitness = selectState();
                                        if (logger.isDebugEnabled()) {
                                                logger.debug("Current trajectory: " + Arrays.toString(context.getTrajectory().toArray()));
-                                                logger.debug("New trajectory is chosen: " + currentTrajectoryWithFittness);
+                                                logger.debug("New trajectory is chosen: " + currentTrajectoryWithFitness);
                                        }
-                                        context.getDesignSpaceManager().executeTrajectoryWithMinimalBacktrackWithoutStateCoding(currentTrajectoryWithFittness.trajectory);
+                                        context.getDesignSpaceManager().executeTrajectoryWithMinimalBacktrackWithoutStateCoding(currentTrajectoryWithFitness.trajectory);
                                }
                        }
                        
 //                      visualiseCurrentState();
-//                      boolean consistencyCheckResult = checkConsistency(currentTrajectoryWithFittness);
+//                      boolean consistencyCheckResult = checkConsistency(currentTrajectoryWithfitness);
 //                      if(consistencyCheckResult == true) {
 //                              continue mainLoop;
 //                      }
@@ -224,10 +221,11 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                                final Object nextActivation = iterator.next();
 //                              if (!iterator.hasNext()) {
 //                                      logger.debug("Last untraversed activation of the state.");
-//                                      trajectoiresToExplore.remove(currentTrajectoryWithFittness);
+//                                      trajectoiresToExplore.remove(currentTrajectoryWithfitness);
 //                              }
                                logger.debug("Executing new activation: " + nextActivation);
                                context.executeAcitvationId(nextActivation);
+                                method.getStatistics().incrementDecisionCount();
                                visualiseCurrentState();
 //                              for(ViatraQueryMatcher<? extends IPatternMatch> matcher : matchers) {
@@ -238,7 +236,7 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
 //                                      
 //                              }
                                
-                                boolean consistencyCheckResult = checkConsistency(currentTrajectoryWithFittness);
+                                boolean consistencyCheckResult = checkConsistency(currentTrajectoryWithFitness);
                                if(consistencyCheckResult == true) { continue mainLoop; }
                                if (context.isCurrentStateAlreadyTraversed()) {
@@ -251,7 +249,7 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                                        logger.debug("Numeric constraints are not satisifed.");
                                        context.backtrack();
                                } else {
-                                        final Fitness nextFitness = calculateFitness();
+                                        final Fitness nextFitness = context.calculateFitness();
                                        checkForSolution(nextFitness);
                                        if (context.getDepth() > configuration.searchSpaceConstraints.maxDepth) {
                                                logger.debug("Reached max depth.");
@@ -259,31 +257,31 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                                                continue;
                                        }
-                                        TrajectoryWithFitness nextTrajectoryWithFittness = new TrajectoryWithFitness(
+                                        TrajectoryWithFitness nextTrajectoryWithfitness = new TrajectoryWithFitness(
                                                        context.getTrajectory().toArray(), nextFitness);
-                                        trajectoiresToExplore.add(nextTrajectoryWithFittness);
+                                        trajectoiresToExplore.add(nextTrajectoryWithfitness);
-                                        int compare = objectiveComparatorHelper.compare(currentTrajectoryWithFittness.fitness,
+                                        int compare = objectiveComparatorHelper.compare(currentTrajectoryWithFitness.fitness,
-                                                        nextTrajectoryWithFittness.fitness);
+                                                        nextTrajectoryWithfitness.fitness);
                                        if (compare < 0) {
                                                logger.debug("Better fitness, moving on: " + nextFitness);
-                                                currentTrajectoryWithFittness = nextTrajectoryWithFittness;
+                                                currentTrajectoryWithFitness = nextTrajectoryWithfitness;
                                                continue mainLoop;
                                        } else if (compare == 0) {
                                                logger.debug("Equally good fitness, moving on: " + nextFitness);
-                                                currentTrajectoryWithFittness = nextTrajectoryWithFittness;
+                                                currentTrajectoryWithFitness = nextTrajectoryWithfitness;
                                                continue mainLoop;
                                        } else {
                                                logger.debug("Worse fitness.");
-                                                currentTrajectoryWithFittness = null;
+                                                currentTrajectoryWithFitness = null;
                                                continue mainLoop;
                                        }
                                }
                        }
                        logger.debug("State is fully traversed.");
-                        trajectoiresToExplore.remove(currentTrajectoryWithFittness);
+                        trajectoiresToExplore.remove(currentTrajectoryWithFitness);
-                        currentTrajectoryWithFittness = null;
+                        currentTrajectoryWithFitness = null;
                }
                logger.info("Interrupted.");
@@ -308,6 +306,7 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                try {
                        activationIds = this.activationSelector.randomizeActivationIDs(context.getUntraversedActivationIds());
                } catch (NullPointerException e) {
+//                      logger.warn("Unexpected state code: " + context.getDesignSpaceManager().getCurrentState());
                        numberOfStatecoderFail++;
                        activationIds = Collections.emptyList();
                }
@@ -315,27 +314,16 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
        }
        private void checkForSolution(final Fitness fittness) {
-                if (fittness.isSatisifiesHardObjectives()) {
+                solutionStore.newSolution(context);
-                        if (solutionStoreWithDiversityDescriptor.isDifferent(context)) {
-                                if(numericSolver.currentSatisfiable()) {
-                                        Map<EObject, EObject> trace = solutionStoreWithCopy.newSolution(context);
-                                        numericSolver.fillSolutionCopy(trace);
-                                        solutionStoreWithDiversityDescriptor.newSolution(context);
-                                        solutionStore.newSolution(context);
-                                        configuration.progressMonitor.workedModelFound(configuration.solutionScope.numberOfRequiredSolution);
-                                        saveTimes();
-                                        logger.debug("Found a solution.");
-                                }
-                        }
-                }
        }
+        
        public List<String> times = new LinkedList<String>();
        private void saveTimes() {
-                long statecoderTime = ((NeighbourhoodBasedPartialInterpretationStateCoder)this.context.getStateCoder()).getStatecoderRuntime()/1000000;
+                long statecoderTime = ((NeighbourhoodBasedPartialInterpretationStateCoder<?, ?>)this.context.getStateCoder()).getStatecoderRuntime()/1000000;
                long forwardTime = context.getDesignSpaceManager().getForwardTime()/1000000;
                long backtrackingTime = context.getDesignSpaceManager().getBacktrackingTime()/1000000;
-                long solutionCopy = solutionStoreWithCopy.getSumRuntime()/1000000;
                long activationSelection = this.activationSelector.getRuntime()/1000000;
+                long solutionCopierTime = this.solutionSaver.getTotalCopierRuntime()/1000000;
                long numericalSolverSumTime = this.numericSolver.getRuntime()/1000000;
                long numericalSolverProblemForming = this.numericSolver.getSolverSolvingProblem()/1000000;
                long numericalSolverSolving = this.numericSolver.getSolverSolvingProblem()/1000000;
@@ -347,8 +335,8 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                        "|Backtrackingtime:"+backtrackingTime+
                        "|GlobalConstraintEvaluationTime:"+(globalConstraintEvaluationTime/1000000)+
                        "|FitnessCalculationTime:"+(fitnessCalculationTime/1000000)+
-                        "|SolutionCopyTime:"+solutionCopy+
                        "|ActivationSelectionTime:"+activationSelection+
+                        "|SolutionCopyTime:"+solutionCopierTime+
                        "|NumericalSolverSumTime:"+numericalSolverSumTime+
                        "|NumericalSolverProblemFormingTime:"+numericalSolverProblemForming+
                        "|NumericalSolverSolvingTime:"+numericalSolverSolving+
@@ -385,13 +373,16 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
        }
        public void visualiseCurrentState() {
-                PartialInterpretationVisualiser partialInterpretatioVisualiser = configuration.debugCongiguration.partialInterpretatioVisualiser;
+                PartialInterpretationVisualiser partialInterpretatioVisualiser = configuration.debugConfiguration.partialInterpretatioVisualiser;
                if(partialInterpretatioVisualiser != null && this.configuration.documentationLevel == DocumentationLevel.FULL && workspace != null) {
                        PartialInterpretation p = (PartialInterpretation) (context.getModel());
                        int id = ++numberOfPrintedModel;
-                        if (id % configuration.debugCongiguration.partalInterpretationVisualisationFrequency == 0) {
+                        if (id % configuration.debugConfiguration.partalInterpretationVisualisationFrequency == 0) {
                                PartialInterpretationVisualisation visualisation = partialInterpretatioVisualiser.visualiseConcretization(p);
-                                visualisation.writeToFile(workspace, String.format("state%09d.png", id));
+                                logger.debug("Visualizing state: " + id + " (" + context.getDesignSpaceManager().getCurrentState() + ")");
+                                String name = String.format("state%09d", id);
+                                visualisation.writeToFile(workspace, name + ".png");
+                                workspace.writeModel((EObject) context.getModel(), name + ".xmi");
                        }
                }
        }
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/DiversityChecker.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/DiversityChecker.xtend
new file mode 100644
index 00000000..fb1b2066
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/DiversityChecker.xtend
@@ -0,0 +1,184 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+import com.google.common.collect.HashMultiset
+import com.google.common.collect.ImmutableSet
+import com.google.common.collect.Multiset
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.AbstractNodeDescriptor
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.NeighbourhoodWithTraces
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2ImmutableTypeLattice
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.DiversityDescriptor
+import java.util.Collection
+import java.util.HashSet
+import java.util.Map
+import java.util.Set
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.xtend.lib.annotations.Accessors
+interface DiversityChecker {
+        public static val NO_DIVERSITY_CHECKER = new DiversityChecker {
+                override isActive() {
+                        false
+                }
+                override getTotalRuntime() {
+                        0
+                }
+                override getSuccessRate() {
+                        1.0
+                }
+                override newSolution(ThreadContext threadContext, Object solutionId, Collection<Object> dominatedSolutionIds) {
+                        true
+                }
+        }
+        def boolean isActive()
+        def long getTotalRuntime()
+        def double getSuccessRate()
+        def boolean newSolution(ThreadContext threadContext, Object solutionId, Collection<Object> dominatedSolutionIds)
+        static def of(DiversityDescriptor descriptor) {
+                if (descriptor.ensureDiversity) {
+                        new NodewiseDiversityChecker(descriptor)
+                } else {
+                        NO_DIVERSITY_CHECKER
+                }
+        }
+}
+abstract class AbstractDiversityChecker implements DiversityChecker {
+        val DiversityDescriptor descriptor
+        val PartialInterpretation2ImmutableTypeLattice solutionCoder = new PartialInterpretation2ImmutableTypeLattice
+        @Accessors(PUBLIC_GETTER) var long totalRuntime = 0
+        var int allCheckCount = 0
+        var int successfulCheckCount = 0
+        protected new(DiversityDescriptor descriptor) {
+                if (!descriptor.ensureDiversity) {
+                        throw new IllegalArgumentException(
+                                "Diversity description should enforce diversity or NO_DIVERSITY_CHECKER should be used instead.")
+                }
+                this.descriptor = descriptor
+        }
+        override isActive() {
+                true
+        }
+        override getTotalRuntime() {
+                throw new UnsupportedOperationException("TODO: auto-generated method stub")
+        }
+        override getSuccessRate() {
+                (allCheckCount as double) / (successfulCheckCount as double)
+        }
+        override newSolution(ThreadContext threadContext, Object solutionId, Collection<Object> dominatedSolutionIds) {
+                val start = System.nanoTime
+                val model = threadContext.model as PartialInterpretation
+                val representation = solutionCoder.createRepresentation(model, descriptor.range, descriptor.parallels,
+                        descriptor.maxNumber, descriptor.relevantTypes, descriptor.relevantRelations)
+                val isDifferent = internalNewSolution(representation, solutionId, dominatedSolutionIds)
+                totalRuntime += System.nanoTime - start
+                allCheckCount++
+                if (isDifferent) {
+                        successfulCheckCount++
+                }
+                isDifferent
+        }
+        protected abstract def boolean internalNewSolution(
+                NeighbourhoodWithTraces<Map<? extends AbstractNodeDescriptor, Integer>, AbstractNodeDescriptor> representation,
+                Object solutionId, Collection<Object> dominatedSolutionIds)
+}
+class NodewiseDiversityChecker extends AbstractDiversityChecker {
+        var Multiset<Integer> nodeCodes = HashMultiset.create
+        val Map<Object, Set<Integer>> tracedNodeCodes = newHashMap
+        new(DiversityDescriptor descriptor) {
+                super(descriptor)
+        }
+        override protected internalNewSolution(
+                NeighbourhoodWithTraces<Map<? extends AbstractNodeDescriptor, Integer>, AbstractNodeDescriptor> representation,
+                Object solutionId, Collection<Object> dominatedSolutionIds) {
+                val nodeCodesInSolution = ImmutableSet.copyOf(representation.modelRepresentation.keySet.map[hashCode])
+                val remainingNodeCodes = if (dominatedSolutionIds.empty) {
+                                nodeCodes
+                        } else {
+                                getRemainingNodeCodes(dominatedSolutionIds)
+                        }
+                val hasNewCode = nodeCodesInSolution.exists[!remainingNodeCodes.contains(it)]
+                if (hasNewCode) {
+                        nodeCodes = remainingNodeCodes
+                        nodeCodes.addAll(nodeCodesInSolution)
+                        for (dominatedSolutionId : dominatedSolutionIds) {
+                                tracedNodeCodes.remove(dominatedSolutionId)
+                        }
+                        tracedNodeCodes.put(solutionId, nodeCodesInSolution)
+                }
+                hasNewCode
+        }
+        private def getRemainingNodeCodes(Collection<Object> dominatedSolutionIds) {
+                // TODO Optimize multiset operations.
+                val copyOfNodeCodes = HashMultiset.create(nodeCodes)
+                for (dominatedSolutionId : dominatedSolutionIds) {
+                        val dominatedModelCode = tracedNodeCodes.get(dominatedSolutionId)
+                        if (dominatedModelCode === null) {
+                                throw new IllegalArgumentException("Unknown dominated solution: " + dominatedSolutionId)
+                        }
+                        copyOfNodeCodes.removeAll(dominatedModelCode)
+                }
+                copyOfNodeCodes
+        }
+}
+class GraphwiseDiversityChecker extends AbstractDiversityChecker {
+        var Set<Integer> modelCodes = newHashSet
+        val Map<Object, Integer> tracedModelCodes = newHashMap
+        new(DiversityDescriptor descriptor) {
+                super(descriptor)
+        }
+        override protected internalNewSolution(
+                NeighbourhoodWithTraces<Map<? extends AbstractNodeDescriptor, Integer>, AbstractNodeDescriptor> representation,
+                Object solutionId, Collection<Object> dominatedSolutionIds) {
+                val modelCodeOfSolution = representation.modelRepresentation.hashCode
+                val remainingModelCodes = if (dominatedSolutionIds.empty) {
+                                modelCodes
+                        } else {
+                                getRemainingModelCodes(dominatedSolutionIds)
+                        }
+                val isNewCode = !remainingModelCodes.contains(modelCodeOfSolution)
+                if (isNewCode) {
+                        modelCodes = remainingModelCodes
+                        modelCodes += modelCodeOfSolution
+                        for (dominatedSolutionId : dominatedSolutionIds) {
+                                tracedModelCodes.remove(dominatedSolutionId)
+                        }
+                        tracedModelCodes.put(solutionId, modelCodeOfSolution)
+                }
+                isNewCode
+        }
+        private def getRemainingModelCodes(Collection<Object> dominatedSolutionIds) {
+                val copyOfModelCodes = new HashSet(modelCodes)
+                for (dominatedSolutionId : dominatedSolutionIds) {
+                        val dominatedModelCode = tracedModelCodes.get(dominatedSolutionId)
+                        if (dominatedModelCode === null) {
+                                throw new IllegalArgumentException("Unknown dominated solution: " + dominatedSolutionId)
+                        }
+                        copyOfModelCodes -= dominatedModelCode
+                }
+                copyOfModelCodes
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/DseUtils.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/DseUtils.xtend
new file mode 100644
index 00000000..3c2e3319
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/DseUtils.xtend
@@ -0,0 +1,66 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.IThreeValuedObjective
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.objectives.Comparators
+import org.eclipse.viatra.dse.objectives.Fitness
+import org.eclipse.viatra.dse.objectives.IObjective
+final class DseUtils {
+        private new() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly.")
+        }
+        static def calculateFitness(ThreadContext it, (IObjective)=>Double getFitness) {
+                val result = new Fitness
+                var boolean satisifiesHardObjectives = true
+                for (objective : objectives) {
+                        val fitness = getFitness.apply(objective)
+                        result.put(objective.name, fitness)
+                        if (objective.isHardObjective() && !objective.satisifiesHardObjective(fitness)) {
+                                satisifiesHardObjectives = false
+                        }
+                }
+                result.satisifiesHardObjectives = satisifiesHardObjectives
+                result
+        }
+        static def caclulateBestPossibleFitness(ThreadContext threadContext) {
+                threadContext.calculateFitness [ objective |
+                        if (objective instanceof IThreeValuedObjective) {
+                                objective.getBestPossibleFitness(threadContext)
+                        } else {
+                                switch (objective.comparator) {
+                                        case Comparators.LOWER_IS_BETTER:
+                                                Double.NEGATIVE_INFINITY
+                                        case Comparators.HIGHER_IS_BETTER:
+                                                Double.POSITIVE_INFINITY
+                                        case Comparators.DIFFERENCE_TO_ZERO_IS_BETTER:
+                                                0.0
+                                        default:
+                                                throw new IllegalArgumentException("Unknown comparator for non-three-valued objective: " +
+                                                        objective.name)
+                                }
+                        }
+                ]
+        }
+        static def caclulateWorstPossibleFitness(ThreadContext threadContext) {
+                threadContext.calculateFitness [ objective |
+                        if (objective instanceof IThreeValuedObjective) {
+                                objective.getWorstPossibleFitness(threadContext)
+                        } else {
+                                switch (objective.comparator) {
+                                        case Comparators.LOWER_IS_BETTER,
+                                        case Comparators.DIFFERENCE_TO_ZERO_IS_BETTER:
+                                                Double.POSITIVE_INFINITY
+                                        case Comparators.HIGHER_IS_BETTER:
+                                                Double.NEGATIVE_INFINITY
+                                        default:
+                                                throw new IllegalArgumentException("Unknown comparator for non-three-valued objective: " +
+                                                        objective.name)
+                                }
+                        }
+                ]
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/InconsistentScopeGlobalConstraint.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/InconsistentScopeGlobalConstraint.xtend
new file mode 100644
index 00000000..2e039ca2
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/InconsistentScopeGlobalConstraint.xtend
@@ -0,0 +1,25 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+import org.eclipse.viatra.dse.objectives.IGlobalConstraint
+import org.eclipse.viatra.dse.base.ThreadContext
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+class InconsistentScopeGlobalConstraint implements IGlobalConstraint {
+        override init(ThreadContext context) {
+                // Nothing to initialize.
+        }
+        override createNew() {
+                this
+        }
+        override getName() {
+                class.name
+        }
+        override checkGlobalConstraint(ThreadContext context) {
+                val partialModel = context.model as PartialInterpretation
+                partialModel.minNewElements <= partialModel.maxNewElements || partialModel.maxNewElements < 0
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/LoggerSolutionFoundHandler.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/LoggerSolutionFoundHandler.xtend
new file mode 100644
index 00000000..39ef5f9a
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/LoggerSolutionFoundHandler.xtend
@@ -0,0 +1,24 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration
+import org.apache.log4j.Logger
+import org.eclipse.viatra.dse.api.SolutionTrajectory
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.solutionstore.ISolutionFoundHandler
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+@FinalFieldsConstructor
+class LoggerSolutionFoundHandler implements ISolutionFoundHandler {
+        val ViatraReasonerConfiguration configuration
+        val logger = Logger.getLogger(SolutionCopier)
+        override solutionFound(ThreadContext context, SolutionTrajectory trajectory) {
+                configuration.progressMonitor.workedModelFound(configuration.solutionScope.numberOfRequiredSolutions)
+                logger.debug("Found a solution.")
+        }
+        override solutionTriedToSave(ThreadContext context, SolutionTrajectory trajectory) {
+                // We are not interested in invalid solutions, ignore.
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend
index a10530c7..d2faaa65 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend
@@ -1,34 +1,20 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+import com.google.common.collect.ImmutableList
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.IThreeValuedObjective
 import java.util.Comparator
 import java.util.List
 import org.eclipse.viatra.dse.base.ThreadContext
 import org.eclipse.viatra.dse.objectives.Comparators
 import org.eclipse.viatra.dse.objectives.IObjective
-import org.eclipse.viatra.dse.objectives.impl.BaseObjective
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
-import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration
-//class ViatraReasonerNumbers {
+class ModelGenerationCompositeObjective implements IThreeValuedObjective {
-//      public static val scopePriority = 2
+        val IObjective scopeObjective
-//      public static val unfinishedMultiplicityPriority = 2
-//      public static val unifinshedWFPriority = 2
-//      //public static val complexityPriority = 4
-//      
-//      public static val scopeWeigth = 1.0
-//      public static val unfinishedMultiplicityWeigth = 1.5
-//      public static val unfinishedWFWeigth = 1.5
-//      //public static val complexityWeigth = 0.1
-//      
-//      public static val useCompositeObjective = true
-//      public static val compositePriority = 2
-//}
-class ModelGenerationCompositeObjective implements IObjective{
-        val ScopeObjective scopeObjective
        val List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives
        val UnfinishedWFObjective unfinishedWFObjective
-        var PartialInterpretation model=null;
+        var PartialInterpretation model = null
        val boolean punishSize
        val int scopeWeight
        val int conaintmentWeight
@@ -36,23 +22,20 @@ class ModelGenerationCompositeObjective implements IObjective{
        val int unfinishedWFWeight
        
        new(
-                ScopeObjective scopeObjective,
+                IObjective scopeObjective,
                List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives,
                UnfinishedWFObjective unfinishedWFObjective,
                ViatraReasonerConfiguration configuration)
        {
-                this.scopeObjective = scopeObjective
+                this(
-                this.unfinishedMultiplicityObjectives = unfinishedMultiplicityObjectives
+                        scopeObjective, unfinishedMultiplicityObjectives, unfinishedWFObjective, configuration.punishSize,
-                this.unfinishedWFObjective = unfinishedWFObjective
+                        configuration.scopeWeight, configuration.conaintmentWeight, configuration.nonContainmentWeight,
-                
+                        configuration.unfinishedWFWeight
-                this.punishSize = configuration.punishSize
+                )
-                this.scopeWeight = configuration.scopeWeight
-                this.conaintmentWeight = configuration.conaintmentWeight
-                this.nonContainmentWeight = configuration.nonContainmentWeight
-                this.unfinishedWFWeight = configuration.unfinishedWFWeight
        }
        new(
-                ScopeObjective scopeObjective,
+                IObjective scopeObjective,
                List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives,
                UnfinishedWFObjective unfinishedWFObjective,
                boolean punishSize, int scopeWeight, int conaintmentWeight, int nonContainmentWeight, int unfinishedWFWeight)
@@ -74,18 +57,21 @@ class ModelGenerationCompositeObjective implements IObjective{
                this.unfinishedMultiplicityObjectives.forEach[it.init(context)]
                this.unfinishedWFObjective.init(context)
        }
-        
        override createNew() {
                return new ModelGenerationCompositeObjective(
-                        this.scopeObjective, this.unfinishedMultiplicityObjectives, this.unfinishedWFObjective,
+                        scopeObjective.createNew,
-                        this.punishSize, this.scopeWeight, this.conaintmentWeight, this.nonContainmentWeight, this.unfinishedWFWeight)
+                        ImmutableList.copyOf(unfinishedMultiplicityObjectives.map[createNew as UnfinishedMultiplicityObjective]),
+                        unfinishedWFObjective.createNew as UnfinishedWFObjective,
+                        punishSize, scopeWeight, conaintmentWeight, nonContainmentWeight, unfinishedWFWeight
+                )
        }
-        
        override getComparator() { Comparators.LOWER_IS_BETTER }
        override getFitness(ThreadContext context) {
                
                val scopeFitnes = scopeObjective.getFitness(context)
-                //val unfinishedMultiplicitiesFitneses = unfinishedMultiplicityObjectives.map[x|x.getFitness(context)]
                val unfinishedWFsFitness = unfinishedWFObjective.getFitness(context)
                
                var containmentMultiplicity = 0.0
@@ -109,24 +95,30 @@ class ModelGenerationCompositeObjective implements IObjective{
                sum += nonContainmentMultiplicity*nonContainmentWeight
                sum += unfinishedWFsFitness*unfinishedWFWeight
                sum+=size
-                
-                //println('''Sum=«sum»|Scope=«scopeFitnes»|ContainmentMultiplicity=«containmentMultiplicity»|NonContainmentMultiplicity=«nonContainmentMultiplicity»|WFs=«unfinishedWFsFitness»''')
-                
                return sum
        }
        
-        override getLevel() { 2 }
+        override getWorstPossibleFitness(ThreadContext threadContext) {
-        override getName() { "CompositeUnfinishednessObjective"}
+                Double.POSITIVE_INFINITY
+        }
        
+        override getBestPossibleFitness(ThreadContext threadContext) {
+                0.0
+        }
+        override getLevel() { 2 }
+        override getName() { "CompositeUnfinishednessObjective" }
        override isHardObjective() { true }
-        override satisifiesHardObjective(Double fitness) { fitness < 0.95 }
-        
+        override satisifiesHardObjective(Double fitness) { fitness <= 0.001 }
-        
        override setComparator(Comparator<Double> comparator) {
-                throw new UnsupportedOperationException("TODO: auto-generated method stub")
+                throw new UnsupportedOperationException("Model generation objective comparator cannot be set.")
        }
        override setLevel(int level) {
-                throw new UnsupportedOperationException("TODO: auto-generated method stub")
+                throw new UnsupportedOperationException("Model generation objective level cannot be set.")
        }
-        
+}
-}
-\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/NumericSolver.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/NumericSolver.xtend
index 0b0feb1a..066040a0 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/NumericSolver.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/NumericSolver.xtend
@@ -21,7 +21,8 @@ import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
 import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint
 class NumericSolver {
-        val ThreadContext threadContext;
+        val ModelGenerationMethod method
+        var ThreadContext threadContext
        val constraint2MustUnitPropagationPrecondition = new HashMap<PConstraint,ViatraQueryMatcher<? extends IPatternMatch>>
        val constraint2CurrentUnitPropagationPrecondition = new HashMap<PConstraint,ViatraQueryMatcher<? extends IPatternMatch>>
        NumericTranslator t = new NumericTranslator
@@ -35,8 +36,16 @@ class NumericSolver {
        var int numberOfSolverCalls = 0
        var int numberOfCachedSolverCalls = 0
        
-        new(ThreadContext threadContext, ModelGenerationMethod method, boolean intermediateConsistencyCheck, boolean caching) {
+        new(ModelGenerationMethod method, boolean intermediateConsistencyCheck, boolean caching) {
-                this.threadContext = threadContext
+                this.method = method
+                this.intermediateConsistencyCheck = intermediateConsistencyCheck
+                this.caching = caching
+        }
+        
+        def init(ThreadContext context) {
+                // This makes the NumericSolver single-threaded,
+                // but that's not a problem, because we only use the solver on a single thread anyways.
+                this.threadContext = context
                val engine = threadContext.queryEngine
                for(entry : method.mustUnitPropagationPreconditions.entrySet) {
                        val constraint = entry.key
@@ -50,8 +59,6 @@ class NumericSolver {
                        val matcher = querySpec.getMatcher(engine);
                        constraint2CurrentUnitPropagationPrecondition.put(constraint,matcher)
                }
-                this.intermediateConsistencyCheck = intermediateConsistencyCheck
-                this.caching = caching
        }
        
        def getRuntime(){runtime}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend
index efc2ef36..cfd11816 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PartialModelAsLogicInterpretation.xtend
@@ -219,4 +219,4 @@ class PartialModelAsLogicInterpretation implements LogicModelInterpretation{
                }
                builder
        }
-}
-\ No newline at end of file
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ScopeObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ScopeObjective.xtend
index 69efe0d7..69a734f8 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ScopeObjective.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ScopeObjective.xtend
@@ -23,9 +23,9 @@ class ScopeObjective implements IObjective{
        
        override getFitness(ThreadContext context) {
                val interpretation = context.model as PartialInterpretation
-                var res = interpretation.minNewElements.doubleValue
+                var res = interpretation.minNewElementsHeuristic.doubleValue
                for(scope : interpretation.scopes) {
-                        res += scope.minNewElements*2
+                        res += scope.minNewElementsHeuristic*2
                }
                return res
        }
@@ -41,4 +41,4 @@ class ScopeObjective implements IObjective{
                throw new UnsupportedOperationException("TODO: auto-generated method stub")
        }
        override getLevel() { 2 }
-}
-\ No newline at end of file
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionCopier.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionCopier.xtend
new file mode 100644
index 00000000..38c8f5a1
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionCopier.xtend
@@ -0,0 +1,86 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+import com.google.common.collect.ImmutableList
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import java.util.LinkedHashMap
+import java.util.List
+import java.util.Map
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.emf.ecore.util.EcoreUtil
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+@FinalFieldsConstructor
+class CopiedSolution {
+        @Accessors val PartialInterpretation partialInterpretations
+        @Accessors val Map<EObject, EObject> trace
+        @Accessors val long copierRuntime
+        @Accessors var boolean current = true
+}
+/**
+ * Based on {@link SolutionStore.BestSolutionSaver}.
+ * 
+ * Will also automatically fill any missing numerical values in the saved solutions
+ * using the supplied {@link NumericSolver}.
+ */
+class SolutionCopier {
+        val NumericSolver numericSolver
+        val copiedSolutions = new LinkedHashMap<Object, CopiedSolution>
+        long startTime = System.nanoTime
+        @Accessors(PUBLIC_GETTER) long totalCopierRuntime = 0
+        new(NumericSolver numericSolver) {
+                this.numericSolver = numericSolver
+        }
+        def void copySolution(ThreadContext context, Object solutionId) {
+                val existingCopy = copiedSolutions.get(solutionId)
+                if (existingCopy === null) {
+                        val copyStart = System.nanoTime
+                        val solution = context.model as PartialInterpretation
+                        val copier = new EcoreUtil.Copier
+                        val copiedPartialInterpretation = copier.copy(solution) as PartialInterpretation
+                        copier.copyReferences
+                        totalCopierRuntime += System.nanoTime - copyStart
+                        val copierRuntime = System.nanoTime - startTime
+                        val copiedSolution = new CopiedSolution(copiedPartialInterpretation, copier, copierRuntime)
+                        numericSolver.fillSolutionCopy(copiedSolution.trace)
+                        copiedSolutions.put(solutionId, copiedSolution)
+                } else {
+                        existingCopy.current = true
+                }
+        }
+        def void markAsObsolete(Object solutionId) {
+                val copiedSolution = copiedSolutions.get(solutionId)
+                if (copiedSolution === null) {
+                        throw new IllegalStateException("No solution to mark as obsolete for state code: " + solutionId)
+                }
+                copiedSolution.current = false
+        }
+        def List<PartialInterpretation> getPartialInterpretations(boolean currentOnly) {
+                getListOfCopiedSolutions(currentOnly).map[partialInterpretations]
+        }
+        def List<Map<EObject, EObject>> getTraces(boolean currentOnly) {
+                getListOfCopiedSolutions(currentOnly).map[trace]
+        }
+        def List<Long> getAllCopierRuntimes(boolean currentOnly) {
+                getListOfCopiedSolutions(currentOnly).map[copierRuntime]
+        }
+        def List<CopiedSolution> getListOfCopiedSolutions(boolean currentOnly) {
+                val values = copiedSolutions.values
+                val filteredSolutions = if (currentOnly) {
+                                values.filter[current]
+                        } else {
+                                values
+                        }
+                ImmutableList.copyOf(filteredSolutions)
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithCopy.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithCopy.xtend
index 21867a4e..4bd2c349 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithCopy.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithCopy.xtend
@@ -1,14 +1,12 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
-import java.util.List
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
 import java.util.LinkedList
-import org.eclipse.emf.ecore.EObject
+import java.util.List
 import java.util.Map
+import org.eclipse.emf.ecore.EObject
 import org.eclipse.emf.ecore.util.EcoreUtil
 import org.eclipse.viatra.dse.base.ThreadContext
-import java.util.TreeMap
-import java.util.SortedMap
 class SolutionStoreWithCopy {
        
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithDiversityDescriptor.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithDiversityDescriptor.xtend
deleted file mode 100644
index 1e7f18a8..00000000
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithDiversityDescriptor.xtend
+++ /dev/null
@@ -1,120 +0,0 @@
-package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2ImmutableTypeLattice
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
-import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.DiversityDescriptor
-import java.util.LinkedList
-import java.util.List
-import org.eclipse.viatra.dse.base.ThreadContext
-import java.util.HashSet
-import java.util.Set
-enum DiversityGranularity {
-        Nodewise, Graphwise
-}
-class SolutionStoreWithDiversityDescriptor {
-        val DiversityDescriptor descriptor
-        DiversityGranularity granularity
-        val PartialInterpretation2ImmutableTypeLattice solutionCoder = new PartialInterpretation2ImmutableTypeLattice
-        val Set<Integer> solutionCodeList = new HashSet
-        
-        var long runtime
-        var int allCheck
-        var int successfulCheck
-        
-        new(DiversityDescriptor descriptor) {
-                if(descriptor.ensureDiversity) {
-                        this.descriptor = descriptor
-                        this.granularity = DiversityGranularity::Nodewise
-                } else {
-                        this.descriptor = null
-                        this.granularity = DiversityGranularity::Nodewise
-                }
-        }
-        
-        def public isActive() {
-                descriptor!==null
-        }
-        
-        def getSumRuntime() {
-                return runtime
-        }
-        def getSuccessRate() {
-                return successfulCheck as double / allCheck
-        }
-        
-        def isDifferent(ThreadContext context) {
-                if(active) {
-                        val start = System.nanoTime
-                        val model = context.model as PartialInterpretation
-                        var boolean isDifferent
-                        if(this.granularity == DiversityGranularity::Graphwise) {
-                                val code = solutionCoder.createRepresentation(model,
-                                descriptor.range,
-                                descriptor.parallels,
-                                descriptor.maxNumber,
-                                descriptor.relevantTypes,
-                                descriptor.relevantRelations).modelRepresentation.hashCode
-                        
-                                isDifferent = !solutionCodeList.contains(code)
-                        } else if(this.granularity == DiversityGranularity::Nodewise){
-                                val codes = solutionCoder.createRepresentation(model,
-                                descriptor.range,
-                                descriptor.parallels,
-                                descriptor.maxNumber,
-                                descriptor.relevantTypes,
-                                descriptor.relevantRelations).modelRepresentation.keySet.map[hashCode].toList
-                                val differentCodes = codes.filter[!solutionCodeList.contains(it)]
-                                //println(differentCodes.size)
-                                
-                                isDifferent = differentCodes.size>=1
-                        } else {
-                                throw new UnsupportedOperationException('''Unsupported diversity type: «this.granularity»''')
-                        }
-                        
-                        runtime += System.nanoTime - start
-                        allCheck++
-                        if(isDifferent) { successfulCheck++ }
-                        return isDifferent
-                } else {
-                        allCheck++
-                        successfulCheck++
-                        return true
-                }
-        }
-        
-        def canBeDifferent(ThreadContext context) {
-                return true
-        }
-        
-        def newSolution(ThreadContext context) {
-                if(active) {
-                        val start = System.nanoTime
-                        val model = context.model as PartialInterpretation
-                        if(this.granularity == DiversityGranularity::Graphwise) {
-                                val code = solutionCoder.createRepresentation(model,
-                                descriptor.range,
-                                descriptor.parallels,
-                                descriptor.maxNumber,
-                                descriptor.relevantTypes,
-                                descriptor.relevantRelations).modelRepresentation.hashCode
-                        
-                                solutionCodeList += code.hashCode
-                        } else if(this.granularity == DiversityGranularity::Nodewise){
-                                val codes = solutionCoder.createRepresentation(model,
-                                descriptor.range,
-                                descriptor.parallels,
-                                descriptor.maxNumber,
-                                descriptor.relevantTypes,
-                                descriptor.relevantRelations).modelRepresentation.keySet.map[hashCode].toList
-                                
-                                solutionCodeList += codes.map[it.hashCode]
-                        } else {
-                                throw new UnsupportedOperationException('''Unsupported diversity type: «this.granularity»''')
-                        }
-                        
-                        runtime += System.nanoTime - start
-                }
-        }
-}
-\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SurelyViolatedObjectiveGlobalConstraint.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SurelyViolatedObjectiveGlobalConstraint.xtend
new file mode 100644
index 00000000..8ed3e912
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SurelyViolatedObjectiveGlobalConstraint.xtend
@@ -0,0 +1,27 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.objectives.IGlobalConstraint
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+@FinalFieldsConstructor
+class SurelyViolatedObjectiveGlobalConstraint implements IGlobalConstraint {
+        val ViatraReasonerSolutionSaver solutionSaver
+        override init(ThreadContext context) {
+                // Nothing to initialize.
+        }
+        override createNew() {
+                this
+        }
+        override getName() {
+                class.name
+        }
+        override checkGlobalConstraint(ThreadContext context) {
+                val bestFitness = DseUtils.caclulateBestPossibleFitness(context)
+                bestFitness.satisifiesHardObjectives && solutionSaver.fitnessMayBeSaved(bestFitness)
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedMultiplicityObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedMultiplicityObjective.xtend
index 2b0807d6..e1582d3b 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedMultiplicityObjective.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedMultiplicityObjective.xtend
@@ -1,15 +1,15 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.MultiplicityGoalConstraintCalculator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.MultiplicityGoalConstraintCalculator
 import java.util.Comparator
 import org.eclipse.viatra.dse.base.ThreadContext
-import org.eclipse.viatra.dse.objectives.IObjective
 import org.eclipse.viatra.dse.objectives.Comparators
+import org.eclipse.viatra.dse.objectives.IObjective
 class UnfinishedMultiplicityObjective implements IObjective {
-        val MultiplicityGoalConstraintCalculator unfinishedMultiplicity;
+        val MultiplicityGoalConstraintCalculator unfinishedMultiplicity
        
-        public new(MultiplicityGoalConstraintCalculator unfinishedMultiplicity) {
+        new(MultiplicityGoalConstraintCalculator unfinishedMultiplicity) {
                this.unfinishedMultiplicity = unfinishedMultiplicity
        }
        
@@ -29,12 +29,13 @@ class UnfinishedMultiplicityObjective implements IObjective {
        override satisifiesHardObjective(Double fitness) { return fitness <=0.01 }
        
        override setComparator(Comparator<Double> comparator) {
-                throw new UnsupportedOperationException("TODO: auto-generated method stub")
+                throw new UnsupportedOperationException
        }
        override setLevel(int level) {
-                throw new UnsupportedOperationException("TODO: auto-generated method stub")
+                throw new UnsupportedOperationException
        }
        def isContainment() {
                return this.unfinishedMultiplicity.containment
        }
-}
-\ No newline at end of file
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedWFObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedWFObjective.xtend
index e0111cf6..1b61ffa5 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedWFObjective.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/UnfinishedWFObjective.xtend
@@ -1,56 +1,64 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
-import org.eclipse.viatra.dse.objectives.IObjective
+import java.util.ArrayList
-import org.eclipse.viatra.query.runtime.api.IPatternMatch
-import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
-import org.eclipse.viatra.query.runtime.api.IQuerySpecification
 import java.util.Collection
-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine
+import java.util.Comparator
-import org.eclipse.viatra.query.runtime.emf.EMFScope
-import org.eclipse.viatra.dse.base.ThreadContext
 import java.util.List
+import org.eclipse.viatra.dse.base.ThreadContext
 import org.eclipse.viatra.dse.objectives.Comparators
-import java.util.ArrayList
+import org.eclipse.viatra.dse.objectives.IObjective
-import java.util.Comparator
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
 class UnfinishedWFObjective implements IObjective {
        Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWFs
        val List<ViatraQueryMatcher<?>> matchers
-        
-        public new(Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWFs) {
+        new(
+                Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWFs) {
                this.unfinishedWFs = unfinishedWFs
                matchers = new ArrayList(unfinishedWFs.size)
        }
        override getName() '''unfinishedWFs'''
        override createNew() {
                return new UnfinishedWFObjective(unfinishedWFs)
        }
        override init(ThreadContext context) {
-                val engine = context.queryEngine//ViatraQueryEngine.on(new EMFScope(context.model))
+                val engine = context.queryEngine // ViatraQueryEngine.on(new EMFScope(context.model))
-                for(unfinishedWF : unfinishedWFs) {
+                for (unfinishedWF : unfinishedWFs) {
                        matchers += unfinishedWF.getMatcher(engine)
                }
        }
-        
        override getComparator() { Comparators.LOWER_IS_BETTER }
        override getFitness(ThreadContext context) {
                var sumOfMatches = 0
-                for(matcher : matchers) {
+                for (matcher : matchers) {
                        val number = matcher.countMatches
-                        //println('''«matcher.patternName» = «number»''')
+//                      if (number > 0) {
-                        sumOfMatches+=number
+//                              println('''«matcher.patternName» = «number»''')
+//                      }
+                        sumOfMatches += number
                }
                return sumOfMatches.doubleValue
        }
-        
        override getLevel() { 2 }
        override isHardObjective() { true }
-        override satisifiesHardObjective(Double fitness) { return fitness <=0.01 }
-        
+        override satisifiesHardObjective(Double fitness) { return fitness <= 0.01 }
        override setComparator(Comparator<Double> comparator) {
-                throw new UnsupportedOperationException("TODO: auto-generated method stub")
+                throw new UnsupportedOperationException()
        }
        override setLevel(int level) {
-                throw new UnsupportedOperationException("TODO: auto-generated method stub")
+                throw new UnsupportedOperationException()
        }
-}
-\ No newline at end of file
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ViatraReasonerSolutionSaver.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ViatraReasonerSolutionSaver.xtend
new file mode 100644
index 00000000..d879d4cc
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ViatraReasonerSolutionSaver.xtend
@@ -0,0 +1,150 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+import java.util.HashMap
+import java.util.Map
+import org.eclipse.viatra.dse.api.DSEException
+import org.eclipse.viatra.dse.api.Solution
+import org.eclipse.viatra.dse.api.SolutionTrajectory
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.objectives.Fitness
+import org.eclipse.viatra.dse.objectives.IObjective
+import org.eclipse.viatra.dse.objectives.ObjectiveComparatorHelper
+import org.eclipse.viatra.dse.solutionstore.SolutionStore.ISolutionSaver
+import org.eclipse.xtend.lib.annotations.Accessors
+/**
+ * Based on {@link SolutionStore.BestSolutionSaver}.
+ * 
+ * Will also automatically fill any missing numerical values in the saved solutions
+ * using the supplied {@link NumericSolver}.
+ */
+class ViatraReasonerSolutionSaver implements ISolutionSaver {
+        @Accessors val SolutionCopier solutionCopier
+        @Accessors val DiversityChecker diversityChecker
+        val boolean hasExtremalObjectives
+        val int numberOfRequiredSolutions
+        val ObjectiveComparatorHelper comparatorHelper
+        val Map<SolutionTrajectory, Fitness> trajectories = new HashMap
+        @Accessors(PUBLIC_SETTER) var Map<Object, Solution> solutionsCollection
+        new(IObjective[][] leveledExtremalObjectives, int numberOfRequiredSolutions, DiversityChecker diversityChecker, NumericSolver numericSolver) {
+                this.diversityChecker = diversityChecker
+                comparatorHelper = new ObjectiveComparatorHelper(leveledExtremalObjectives)
+                hasExtremalObjectives = leveledExtremalObjectives.exists[!empty]
+                this.numberOfRequiredSolutions = numberOfRequiredSolutions
+                this.solutionCopier = new SolutionCopier(numericSolver)
+        }
+        override saveSolution(ThreadContext context, Object id, SolutionTrajectory solutionTrajectory) {
+                if (hasExtremalObjectives) {
+                        saveBestSolutionOnly(context, id, solutionTrajectory)
+                } else {
+                        saveAnyDiverseSolution(context, id, solutionTrajectory)
+                }
+        }
+        private def saveBestSolutionOnly(ThreadContext context, Object id, SolutionTrajectory solutionTrajectory) {
+                val fitness = context.lastFitness
+                if (!shouldSaveSolution(fitness, context)) {
+                        return false
+                }
+                val dominatedTrajectories = newArrayList
+                for (entry : trajectories.entrySet) {
+                        val isLastFitnessBetter = comparatorHelper.compare(fitness, entry.value)
+                        if (isLastFitnessBetter < 0) {
+                                // Found a trajectory that dominates the current one, no need to save
+                                return false
+                        }
+                        if (isLastFitnessBetter > 0) {
+                                dominatedTrajectories += entry.key
+                        }
+                }
+                if (dominatedTrajectories.size == 0 && !needsMoreSolutionsWithSameFitness) {
+                        return false
+                }
+                if (!diversityChecker.newSolution(context, id, dominatedTrajectories.map[solution.stateCode])) {
+                        return false
+                }
+                // We must save the new trajectory before removing dominated trajectories
+                // to avoid removing the current solution when it is reachable only via dominated trajectories.
+                val solutionSaved = basicSaveSolution(context, id, solutionTrajectory, fitness)
+                for (dominatedTrajectory : dominatedTrajectories) {
+                        trajectories -= dominatedTrajectory
+                        val dominatedSolution = dominatedTrajectory.solution
+                        if (!dominatedSolution.trajectories.remove(dominatedTrajectory)) {
+                                throw new DSEException(
+                                        "Dominated solution is not reachable from dominated trajectory. This should never happen!")
+                        }
+                        if (dominatedSolution.trajectories.empty) {
+                                val dominatedSolutionId = dominatedSolution.stateCode
+                                solutionCopier.markAsObsolete(dominatedSolutionId)
+                                solutionsCollection -= dominatedSolutionId
+                        }
+                }
+                solutionSaved
+        }
+        private def saveAnyDiverseSolution(ThreadContext context, Object id, SolutionTrajectory solutionTrajectory) {
+                val fitness = context.lastFitness
+                if (!shouldSaveSolution(fitness, context)) {
+                        return false
+                }
+                if (!diversityChecker.newSolution(context, id, emptyList)) {
+                        return false
+                }
+                basicSaveSolution(context, id, solutionTrajectory, fitness)
+        }
+        private def shouldSaveSolution(Fitness fitness, ThreadContext context) {
+                return fitness.satisifiesHardObjectives
+        }
+        private def basicSaveSolution(ThreadContext context, Object id, SolutionTrajectory solutionTrajectory,
+                Fitness fitness) {
+                var boolean solutionSaved = false
+                var dseSolution = solutionsCollection.get(id)
+                if (dseSolution === null) {
+                        solutionCopier.copySolution(context, id)
+                        dseSolution = new Solution(id, solutionTrajectory)
+                        solutionsCollection.put(id, dseSolution)
+                        solutionSaved = true
+                } else {
+                        solutionSaved = dseSolution.trajectories.add(solutionTrajectory)
+                }
+                if (solutionSaved) {
+                        solutionTrajectory.solution = dseSolution
+                        trajectories.put(solutionTrajectory, fitness)
+                }
+                solutionSaved
+        }
+        def fitnessMayBeSaved(Fitness fitness) {
+                if (!hasExtremalObjectives) {
+                        return true
+                }
+                var boolean mayDominate
+                for (existingFitness : trajectories.values) {
+                        val isNewFitnessBetter = comparatorHelper.compare(fitness, existingFitness)
+                        if (isNewFitnessBetter < 0) {
+                                return false
+                        }
+                        if (isNewFitnessBetter > 0) {
+                                mayDominate = true
+                        }
+                }
+                mayDominate || needsMoreSolutionsWithSameFitness
+        }
+        private def boolean needsMoreSolutionsWithSameFitness() {
+                if (solutionsCollection === null) {
+                        // The solutions collection will only be initialized upon saving the first solution.
+                        return true
+                }
+                solutionsCollection.size < numberOfRequiredSolutions
+        }
+        
+        def getTotalCopierRuntime() {
+                solutionCopier.totalCopierRuntime
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/WF2ObjectiveConverter.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/WF2ObjectiveConverter.xtend
index 5a528a9e..6d772f32 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/WF2ObjectiveConverter.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/WF2ObjectiveConverter.xtend
@@ -1,5 +1,6 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+import com.google.common.collect.ImmutableList
 import java.util.ArrayList
 import java.util.Collection
 import org.eclipse.viatra.dse.objectives.Comparators
@@ -12,25 +13,33 @@ import org.eclipse.viatra.query.runtime.api.IQuerySpecification
 import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
 class WF2ObjectiveConverter {
-        
+        static val INVALIDATED_WFS_NAME = "invalidatedWFs"
        def createCompletenessObjective(
-                Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWF)
+                Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWF) {
-        {
+                new UnfinishedWFObjective(unfinishedWF)
-                val res = new ConstraintsObjective('''unfinishedWFs''',
+        }
-                        unfinishedWF.map[
-                                new QueryConstraint(it.fullyQualifiedName,it,2.0)
+        def createInvalidationObjective(
-                        ].toList
+                Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidatedByWF) {
+                createConstraintObjective(INVALIDATED_WFS_NAME, invalidatedByWF)
+        }
+        def IGlobalConstraint createInvalidationGlobalConstraint(
+                Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidatedByWF) {
+                new ModelQueriesGlobalConstraint(INVALIDATED_WFS_NAME, new ArrayList(invalidatedByWF))
+        }
+        private def createConstraintObjective(String name,
+                Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> queries) {
+                val res = new ConstraintsObjective(
+                        name,
+                        ImmutableList.copyOf(queries.map [
+                                new QueryConstraint(it.fullyQualifiedName, it, 1.0)
+                        ])
                )
                res.withComparator(Comparators.LOWER_IS_BETTER)
                res.level = 2
-                return res
+                res
-        }
-        
-        def IGlobalConstraint createInvalidationObjective(
-                Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidatedByWF)
-        {
-                return new ModelQueriesGlobalConstraint('''invalidatedWFs''',
-                        new ArrayList(invalidatedByWF)
-                )
        }
-}
-\ No newline at end of file
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/AbstractThreeValuedObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/AbstractThreeValuedObjective.xtend
new file mode 100644
index 00000000..cd911ab5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/AbstractThreeValuedObjective.xtend
@@ -0,0 +1,35 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+import org.eclipse.viatra.dse.base.ThreadContext
+abstract class AbstractThreeValuedObjective extends DirectionalThresholdObjective implements IThreeValuedObjective {
+        protected new(String name, ObjectiveKind kind, ObjectiveThreshold threshold, int level) {
+                super(name, kind, threshold, level)
+        }
+        abstract def double getLowestPossibleFitness(ThreadContext threadContext)
+        abstract def double getHighestPossibleFitness(ThreadContext threadContext)
+        override getWorstPossibleFitness(ThreadContext threadContext) {
+                switch (kind) {
+                        case LOWER_IS_BETTER:
+                                getHighestPossibleFitness(threadContext)
+                        case HIGHER_IS_BETTER:
+                                getLowestPossibleFitness(threadContext)
+                        default:
+                                throw new IllegalStateException("Unknown three valued objective kind: " + kind)
+                }
+        }
+        override getBestPossibleFitness(ThreadContext threadContext) {
+                switch (kind) {
+                        case LOWER_IS_BETTER:
+                                getLowestPossibleFitness(threadContext)
+                        case HIGHER_IS_BETTER:
+                                getHighestPossibleFitness(threadContext)
+                        default:
+                                throw new IllegalStateException("Unknown three valued objective kind: " + kind)
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CompositeDirectionalThresholdObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CompositeDirectionalThresholdObjective.xtend
new file mode 100644
index 00000000..0aa442f5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CompositeDirectionalThresholdObjective.xtend
@@ -0,0 +1,62 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+import com.google.common.collect.ImmutableList
+import java.util.Collection
+import org.eclipse.viatra.dse.base.ThreadContext
+class CompositeDirectionalThresholdObjective extends DirectionalThresholdObjective {
+        val Collection<DirectionalThresholdObjective> objectives
+        new(String name, Collection<DirectionalThresholdObjective> objectives) {
+                this(name, objectives, getKind(objectives), getThreshold(objectives), getLevel(objectives))
+        }
+        new(String name, DirectionalThresholdObjective... objectives) {
+                this(name, objectives as Collection<DirectionalThresholdObjective>)
+        }
+        protected new(String name, Iterable<DirectionalThresholdObjective> objectives, ObjectiveKind kind,
+                ObjectiveThreshold threshold, int level) {
+                super(name, kind, threshold, level)
+                this.objectives = ImmutableList.copyOf(objectives)
+        }
+        override createNew() {
+                new CompositeDirectionalThresholdObjective(name, objectives.map[createNew as DirectionalThresholdObjective],
+                        kind, threshold, level)
+        }
+        override init(ThreadContext context) {
+                for (objective : objectives) {
+                        objective.init(context)
+                }
+        }
+        override protected getRawFitness(ThreadContext context) {
+                var double fitness = 0
+                for (objective : objectives) {
+                        fitness += objective.getFitness(context)
+                }
+                fitness
+        }
+        private static def getKind(Collection<DirectionalThresholdObjective> objectives) {
+                val kinds = objectives.map[kind].toSet
+                if (kinds.size != 1) {
+                        throw new IllegalArgumentException("Passed objectives must have the same kind")
+                }
+                kinds.head
+        }
+        private static def getThreshold(Collection<DirectionalThresholdObjective> objectives) {
+                objectives.map[threshold].reduce[a, b|a.merge(b)]
+        }
+        private static def int getLevel(Collection<DirectionalThresholdObjective> objectives) {
+                val levels = objectives.map[level].toSet
+                if (levels.size != 1) {
+                        throw new IllegalArgumentException("Passed objectives must have the same level")
+                }
+                levels.head
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/DirectionalThresholdObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/DirectionalThresholdObjective.xtend
new file mode 100644
index 00000000..376e3d1a
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/DirectionalThresholdObjective.xtend
@@ -0,0 +1,164 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+import java.util.Comparator
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.objectives.IObjective
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.Data
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+abstract class ObjectiveThreshold {
+        public static val NO_THRESHOLD = new ObjectiveThreshold {
+                override isHard() {
+                        false
+                }
+                override satisfiesThreshold(double cost, Comparator<Double> comparator) {
+                        true
+                }
+                override protected postProcessSatisfactoryCost(double cost, ObjectiveKind kind) {
+                        cost
+                }
+                override ObjectiveThreshold merge(ObjectiveThreshold other) {
+                        if (other == NO_THRESHOLD) {
+                                NO_THRESHOLD
+                        } else {
+                                throw new IllegalArgumentException("Merged thresholds must have the same type")
+                        }
+                }
+        }
+        private new() {
+        }
+        def boolean isHard() {
+                true
+        }
+        def boolean satisfiesThreshold(double cost, ObjectiveKind kind) {
+                satisfiesThreshold(cost, kind.comparator)
+        }
+        def boolean satisfiesThreshold(double cost, Comparator<Double> comparator)
+        def double postProcessCost(double cost, ObjectiveKind kind) {
+                if (satisfiesThreshold(cost, kind)) {
+                        postProcessSatisfactoryCost(cost, kind)
+                } else {
+                        cost
+                }
+        }
+        protected def double postProcessSatisfactoryCost(double cost, ObjectiveKind kind)
+        def ObjectiveThreshold merge(ObjectiveThreshold other)
+        @Data
+        static class Exclusive extends ObjectiveThreshold {
+                static val EPSILON = 0.1
+                val double threshold
+                val boolean clampToThreshold
+                @FinalFieldsConstructor
+                new() {
+                }
+                new(double threshold) {
+                        this(threshold, true)
+                }
+                override satisfiesThreshold(double cost, Comparator<Double> comparator) {
+                        comparator.compare(threshold, cost) < 0
+                }
+                override protected postProcessSatisfactoryCost(double cost, ObjectiveKind kind) {
+                        if (clampToThreshold) {
+                                threshold + Math.signum(kind.satisfiedValue) * EPSILON
+                        } else {
+                                cost
+                        }
+                }
+                override ObjectiveThreshold merge(ObjectiveThreshold other) {
+                        if (other instanceof Exclusive) {
+                                new Exclusive(threshold + other.threshold)
+                        } else {
+                                throw new IllegalArgumentException("Merged thresholds must have the same type")
+                        }
+                }
+        }
+        @Data
+        static class Inclusive extends ObjectiveThreshold {
+                val double threshold
+                val boolean clampToThreshold
+                @FinalFieldsConstructor
+                new() {
+                }
+                new(double threshold) {
+                        this(threshold, true)
+                }
+                override satisfiesThreshold(double cost, Comparator<Double> comparator) {
+                        comparator.compare(threshold, cost) <= 0
+                }
+                override protected postProcessSatisfactoryCost(double cost, ObjectiveKind kind) {
+                        if (clampToThreshold) {
+                                threshold
+                        } else {
+                                cost
+                        }
+                }
+                
+                override ObjectiveThreshold merge(ObjectiveThreshold other) {
+                        if (other instanceof Inclusive) {
+                                new Inclusive(threshold + other.threshold)
+                        } else {
+                                throw new IllegalArgumentException("Merged thresholds must have the same type")
+                        }
+                }
+        }
+}
+abstract class DirectionalThresholdObjective implements IObjective {
+        @Accessors val String name
+        @Accessors ObjectiveKind kind
+        @Accessors ObjectiveThreshold threshold
+        @Accessors int level
+        protected new(String name, ObjectiveKind kind, ObjectiveThreshold threshold, int level) {
+                this.name = name
+                this.kind = kind
+                this.threshold = threshold
+                this.level = level
+        }
+        override isHardObjective() {
+                threshold.hard
+        }
+        override satisifiesHardObjective(Double fitness) {
+                threshold.satisfiesThreshold(fitness, comparator)
+        }
+        override getComparator() {
+                kind.comparator
+        }
+        override setComparator(Comparator<Double> comparator) {
+                kind = ObjectiveKind.fromComparator(comparator)
+        }
+        override getFitness(ThreadContext context) {
+                val fitness = getRawFitness(context)
+                threshold.postProcessCost(fitness, kind)
+        }
+        protected def double getRawFitness(ThreadContext context)
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IThreeValuedObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IThreeValuedObjective.xtend
new file mode 100644
index 00000000..4a870a3e
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IThreeValuedObjective.xtend
@@ -0,0 +1,10 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.objectives.IObjective
+interface IThreeValuedObjective extends IObjective {
+        def Double getWorstPossibleFitness(ThreadContext threadContext)
+        
+        def Double getBestPossibleFitness(ThreadContext threadContext)
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/MatchCostObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/MatchCostObjective.xtend
new file mode 100644
index 00000000..a0c6a2c1
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/MatchCostObjective.xtend
@@ -0,0 +1,52 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+import com.google.common.collect.ImmutableList
+import java.util.Collection
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.xtend.lib.annotations.Data
+@Data
+class MatchCostElement {
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> querySpecification
+        val double weight
+}
+class MatchCostObjective extends DirectionalThresholdObjective {
+        val Collection<MatchCostElement> costElements
+        Collection<CostElementMatcher> matchers
+        new(String name, Collection<MatchCostElement> costElements, ObjectiveKind kind, ObjectiveThreshold threshold,
+                int level) {
+                super(name, kind, threshold, level)
+                this.costElements = costElements
+        }
+        override createNew() {
+                new MatchCostObjective(name, costElements, kind, threshold, level)
+        }
+        override init(ThreadContext context) {
+                val queryEngine = context.queryEngine
+                matchers = ImmutableList.copyOf(costElements.map [
+                        val matcher = querySpecification.getMatcher(queryEngine)
+                        new CostElementMatcher(matcher, weight)
+                ])
+        }
+        override protected getRawFitness(ThreadContext context) {
+                var double cost = 0
+                for (it : matchers) {
+                        cost += weight * matcher.countMatches
+                }
+                cost
+        }
+        @Data
+        private static class CostElementMatcher {
+                val ViatraQueryMatcher<? extends IPatternMatch> matcher
+                val double weight
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ObjectiveKind.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ObjectiveKind.java
new file mode 100644
index 00000000..cbbaaafd
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ObjectiveKind.java
@@ -0,0 +1,60 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization;
+import java.util.Comparator;
+import org.eclipse.viatra.dse.objectives.Comparators;
+public enum ObjectiveKind {
+        LOWER_IS_BETTER {
+                @Override
+                public Comparator<Double> getComparator() {
+                        return Comparators.LOWER_IS_BETTER;
+                }
+                @Override
+                public double getInvalidValue() {
+                        return Double.POSITIVE_INFINITY;
+                }
+                @Override
+                public double getSatisfiedValue() {
+                        return Double.NEGATIVE_INFINITY;
+                }
+        },
+        HIGHER_IS_BETTER {
+                @Override
+                public Comparator<Double> getComparator() {
+                        return Comparators.HIGHER_IS_BETTER;
+                }
+                @Override
+                public double getInvalidValue() {
+                        return Double.NEGATIVE_INFINITY;
+                }
+                @Override
+                public double getSatisfiedValue() {
+                        return Double.POSITIVE_INFINITY;
+                }
+        };
+        public abstract Comparator<Double> getComparator();
+        public abstract double getInvalidValue();
+        public abstract double getSatisfiedValue();
+        public static ObjectiveKind fromComparator(Comparator<Double> comparator) {
+                if (Comparators.LOWER_IS_BETTER.equals(comparator)) {
+                        return ObjectiveKind.LOWER_IS_BETTER;
+                } else if (Comparators.HIGHER_IS_BETTER.equals(comparator)) {
+                        return ObjectiveKind.HIGHER_IS_BETTER;
+                } else {
+                        throw new IllegalStateException("Only LOWER_IS_BETTER and HIGHER_IS_BETTER comparators are supported.");
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/QueryBasedObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/QueryBasedObjective.xtend
new file mode 100644
index 00000000..d355f5be
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/QueryBasedObjective.xtend
@@ -0,0 +1,48 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+class QueryBasedObjective extends DirectionalThresholdObjective {
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> querySpecification
+        ViatraQueryMatcher<? extends IPatternMatch> matcher
+        new(IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> querySpecification,
+                ObjectiveKind kind, ObjectiveThreshold threshold, int level) {
+                super(querySpecification.simpleName + " objective", kind, threshold, level)
+                if (querySpecification.parameters.size != 1) {
+                        throw new IllegalArgumentException("Objective query must have a single parameter")
+                }
+                this.querySpecification = querySpecification
+        }
+        override createNew() {
+                new QueryBasedObjective(querySpecification, kind, threshold, level)
+        }
+        override init(ThreadContext context) {
+                matcher = querySpecification.getMatcher(context.queryEngine)
+        }
+        override protected getRawFitness(ThreadContext context) {
+                val iterator = matcher.allMatches.iterator
+                if (!iterator.hasNext) {
+                        return invalidValue
+                }
+                val value = iterator.next.get(0)
+                if (iterator.hasNext) {
+                        throw new IllegalStateException("Multiple matches for objective query")
+                }
+                if (value instanceof Number) {
+                        value.doubleValue
+                } else {
+                        throw new IllegalStateException("Objective value is not an instance of Number")
+                }
+        }
+        private def getInvalidValue() {
+                kind.invalidValue
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjective.xtend
new file mode 100644
index 00000000..0a6fd55b
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjective.xtend
@@ -0,0 +1,85 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+import com.google.common.collect.ImmutableList
+import java.util.Collection
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.xtend.lib.annotations.Data
+@Data
+class ThreeValuedCostElement {
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> currentMatchQuery
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> mayMatchQuery
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> mustMatchQuery
+        val int weight
+}
+class ThreeValuedCostObjective extends AbstractThreeValuedObjective {
+        val Collection<ThreeValuedCostElement> costElements
+        Collection<CostElementMatchers> matchers
+        new(String name, Collection<ThreeValuedCostElement> costElements, ObjectiveKind kind, ObjectiveThreshold threshold,
+                int level) {
+                super(name, kind, threshold, level)
+                this.costElements = costElements
+        }
+        override createNew() {
+                new ThreeValuedCostObjective(name, costElements, kind, threshold, level)
+        }
+        override init(ThreadContext context) {
+                val queryEngine = context.queryEngine
+                matchers = ImmutableList.copyOf(costElements.map [ element |
+                        new CostElementMatchers(
+                                queryEngine.getMatcher(element.currentMatchQuery),
+                                queryEngine.getMatcher(element.mayMatchQuery),
+                                queryEngine.getMatcher(element.mustMatchQuery),
+                                element.weight
+                        )
+                ])
+        }
+        override getRawFitness(ThreadContext context) {
+                var int cost = 0
+                for (matcher : matchers) {
+                        cost += matcher.weight * matcher.currentMatcher.countMatches
+                }
+                cost as double
+        }
+        override getLowestPossibleFitness(ThreadContext threadContext) {
+                var int cost = 0
+                for (matcher : matchers) {
+                        if (matcher.weight >= 0) {
+                                cost += matcher.weight * matcher.mustMatcher.countMatches
+                        } else if (matcher.mayMatcher.countMatches > 0) {
+                                // TODO Count may matches.
+                                return Double.NEGATIVE_INFINITY
+                        }
+                }
+                cost as double
+        }
+        override getHighestPossibleFitness(ThreadContext threadContext) {
+                var int cost = 0
+                for (matcher : matchers) {
+                        if (matcher.weight <= 0) {
+                                cost += matcher.weight * matcher.mustMatcher.countMatches
+                        } else if (matcher.mayMatcher.countMatches > 0) {
+                                return Double.POSITIVE_INFINITY
+                        }
+                }
+                cost as double
+        }
+        @Data
+        private static class CostElementMatchers {
+                val ViatraQueryMatcher<? extends IPatternMatch> currentMatcher
+                val ViatraQueryMatcher<? extends IPatternMatch> mayMatcher
+                val ViatraQueryMatcher<? extends IPatternMatch> mustMatcher
+                val int weight
+        }
+}