fix merging issue

217 files changed, 21862 insertions, 2854 deletions

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..ec1557e8 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,8 +4,12 @@ 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
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules
 Require-Bundle: hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0",
  hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage;bundle-version="1.0.0",
  hu.bme.mit.inf.dslreasoner.ecore2logic;bundle-version="1.0.0",
@@ -14,13 +18,16 @@ Require-Bundle: hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0",
  org.eclipse.xtext.xbase.lib,
  org.eclipse.xtend.lib,
  org.eclipse.xtend.lib.macro,
- org.eclipse.viatra.query.runtime;bundle-version="1.5.0",
- org.eclipse.viatra.query.runtime.base.itc;bundle-version="1.5.0",
- org.eclipse.viatra.query.patternlanguage.emf;bundle-version="1.5.0",
+ org.eclipse.viatra.query.runtime;bundle-version="2.0.0",
+ org.eclipse.viatra.query.runtime.base.itc;bundle-version="2.0.0",
+ org.eclipse.viatra.query.patternlanguage.emf;bundle-version="2.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.viatra.transformation.runtime.emf;bundle-version="2.0.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",
+ org.eclipse.viatra.query.runtime.rete;bundle-version="2.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/,\

-           src-gen/

+           xtend-gen/

 output.. = bin/

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/plugin.xml b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/plugin.xml
index 05e00983..6e4d96ca 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/plugin.xml
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/plugin.xml
@@ -1,14 +1,14 @@
-<?xml version="1.0" encoding="UTF-8"?><plugin>

-  <extension id="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.TypeAnalysis" point="org.eclipse.viatra.query.runtime.queryspecification">

-    <group group="org.eclipse.viatra.query.runtime.extensibility.SingletonExtensionFactory:hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.TypeAnalysis" id="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.TypeAnalysis">

-      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.hasDefinedSupertype"/>

-      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.dontHaveDefinedSupertype"/>

-      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.newElementTypeConstructor"/>

-      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.newElementTypeRefinementTarget"/>

-      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.incompatibleSuperType"/>

-      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.incompatibleTopType"/>

-      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.newElementTypeRefinementNegativeConstraint"/>

-      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.newElementMayTypeNegativeConstraint"/>

-    </group>

-  </extension>

-</plugin>

+<?xml version="1.0" encoding="UTF-8"?><plugin>
+  <extension id="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.TypeAnalysis" point="org.eclipse.viatra.query.runtime.queryspecification">
+    <group group="org.eclipse.viatra.query.runtime.extensibility.SingletonExtensionFactory:hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.TypeAnalysis" id="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.TypeAnalysis">
+      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.hasDefinedSupertype"/>
+      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.dontHaveDefinedSupertype"/>
+      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.newElementTypeConstructor"/>
+      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.newElementTypeRefinementTarget"/>
+      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.incompatibleSuperType"/>
+      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.incompatibleTopType"/>
+      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.newElementTypeRefinementNegativeConstraint"/>
+      <query-specification fqn="hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries.newElementMayTypeNegativeConstraint"/>
+    </group>
+  </extension>
+</plugin>
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;

-                else if(this.isMust())return MAY;

-                else return MUST;

+                switch (this) {

+                case CURRENT:

+                        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
deleted file mode 100644
index 8a26470a..00000000
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend
+++ /dev/null
@@ -1,97 +0,0 @@
-package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra

-

-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.patterns.PatternProvider

-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules.GoalConstraintProvider

-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules.RefinementRuleProvider

-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.List

-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.queries.PQuery

-import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule

-import org.eclipse.xtend.lib.annotations.Data

-

-class ModelGenerationStatistics {

-        public var long transformationExecutionTime = 0

-        public var long metricCalculationTime = 0

-        

-        synchronized def addExecutionTime(long amount) {

-                transformationExecutionTime+=amount

-        }

-        

-        synchronized def addMetricCalculationTime(long amount) {

-                metricCalculationTime+=amount

-        }

-        

-        public var long PreliminaryTypeAnalisisTime = 0

-}

-@Data class ModelGenerationMethod {

-         ModelGenerationStatistics statistics

-         

-         Collection<? extends BatchTransformationRule<?,?>> objectRefinementRules

-         Collection<? extends BatchTransformationRule<?,?>> relationRefinementRules

-         

-         List<MultiplicityGoalConstraintCalculator> unfinishedMultiplicities

-         Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWF

-         

-         Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidWF

-         

-         Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allPatterns

-}

-enum TypeInferenceMethod {

-        Generic, PreliminaryAnalysis

-}

-

-class ModelGenerationMethodProvider {

-        private val PatternProvider patternProvider = new PatternProvider

-        private val RefinementRuleProvider refinementRuleProvider = new RefinementRuleProvider

-        private val GoalConstraintProvider goalConstraintProvider = new GoalConstraintProvider

-        

-        public def ModelGenerationMethod createModelGenerationMethod(

-                LogicProblem logicProblem,

-                PartialInterpretation emptySolution,

-                ReasonerWorkspace workspace,

-                boolean nameNewElements,

-                TypeInferenceMethod typeInferenceMethod,

-                ScopePropagator scopePropagator,

-                DocumentationLevel debugLevel

-        ) {

-                val statistics = new ModelGenerationStatistics

-                val writeFiles = (debugLevel === DocumentationLevel.NORMAL || debugLevel === DocumentationLevel.FULL)

-                

-                val Set<PQuery> existingQueries = logicProblem

-                        .relations

-                        .map[annotations]

-                        .flatten

-                        .filter(TransfomedViatraQuery)

-                        .map[it.patternPQuery as PQuery]

-                        .toSet

-                

-                val queries = patternProvider.generateQueries(logicProblem,emptySolution,statistics,existingQueries,workspace,typeInferenceMethod,writeFiles) 

-                val //LinkedHashMap<Pair<Relation, ? extends Type>, BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>>

-                        objectRefinementRules = refinementRuleProvider.createObjectRefinementRules(queries,scopePropagator,nameNewElements,statistics)

-                val relationRefinementRules = refinementRuleProvider.createRelationRefinementRules(queries,statistics)

-                

-                val unfinishedMultiplicities = goalConstraintProvider.getUnfinishedMultiplicityQueries(queries)

-                val unfinishedWF = queries.getUnfinishedWFQueries.values

-                

-                val invalidWF = queries.getInvalidWFQueries.values

-                

-                return new ModelGenerationMethod(

-                        statistics,

-                        objectRefinementRules.values,

-                        relationRefinementRules.values,

-                        unfinishedMultiplicities,

-                        unfinishedWF,

-                        invalidWF,

-                        queries.allQueries

-                )

-        }

-}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationStatistics.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationStatistics.xtend
new file mode 100644
index 00000000..ab4fa039
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationStatistics.xtend
@@ -0,0 +1,52 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra
+
+class ModelGenerationStatistics {
+        public var long transformationExecutionTime = 0
+        public var long metricCalculationTime = 0
+        
+        
+        synchronized def addMetricCalculationTime(long amount) {
+                metricCalculationTime+=amount
+        }
+        synchronized def addExecutionTime(long amount) {
+                transformationExecutionTime += amount
+        }
+
+        public var long scopePropagationTime = 0
+
+        synchronized def addScopePropagationTime(long amount) {
+                scopePropagationTime += amount
+        }
+
+        public var long mustRelationPropagationTime = 0
+
+        synchronized def addMustRelationPropagationTime(long amount) {
+                mustRelationPropagationTime += 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++
+        }
+}
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/MultiplicityGoalConstraintCalculator.xtend
deleted file mode 100644
index e05160d0..00000000
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend
+++ /dev/null
@@ -1,46 +0,0 @@
-package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra

-

-import org.eclipse.emf.common.notify.Notifier

-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

-

-class MultiplicityGoalConstraintCalculator {

-        val String targetRelationName;

-        val IQuerySpecification<?> querySpecification;

-        var ViatraQueryMatcher<?> matcher;

-                

-        public new(String targetRelationName, IQuerySpecification<?> querySpecification) {

-                this.targetRelationName = targetRelationName

-                this.querySpecification = querySpecification

-                this.matcher = null

-        }

-        

-        public new(MultiplicityGoalConstraintCalculator other) {

-                this.targetRelationName = other.targetRelationName

-                this.querySpecification = other.querySpecification

-                this.matcher = null

-        }

-        

-        def public getName() {

-                targetRelationName

-        }

-        

-        def public init(Notifier notifier) {

-                val engine = ViatraQueryEngine.on(new EMFScope(notifier))

-                matcher = querySpecification.getMatcher(engine)

-        }

-        

-        def public calculateValue() {

-                var res = 0

-                val allMatches = this.matcher.allMatches

-                for(match : allMatches) {

-                        //println(targetRelationName+ " missing multiplicity: "+match.get(3))

-                        val missingMultiplicity = match.get(4) as Integer

-                        res += missingMultiplicity

-                }

-                //println(targetRelationName+ " all missing multiplicities: "+res)

-                return res

-        }

-}
\ 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/PropagationModality.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/PropagationModality.java
new file mode 100644
index 00000000..2288ad7e
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/PropagationModality.java
@@ -0,0 +1,8 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra;

+

+public enum PropagationModality {

+        /**The value was originally ? and set to 1 */

+        UP, 

+        /**The value was originally ? and set to 0 */

+        DOWN

+}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/TypeInferenceMethod.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/TypeInferenceMethod.xtend
new file mode 100644
index 00000000..9296a0be
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/TypeInferenceMethod.xtend
@@ -0,0 +1,44 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra

+

+import com.google.common.collect.ImmutableMap

+import com.google.common.collect.ImmutableSet

+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.CachingSimplePolyhedronScopePropagatorStrategy

+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.patterns.UnitPropagationPatternGenerator

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules.GoalConstraintProvider

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules.RefinementRuleProvider

+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.List

+import java.util.Map

+import java.util.Set

+import org.eclipse.viatra.query.runtime.api.GenericQueryGroup

+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.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

+

+enum TypeInferenceMethod {

+        Generic,

+        PreliminaryAnalysis

+}
\ 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/ExtendedLinearExpressionBuilderFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ExtendedLinearExpressionBuilderFactory.xtend
new file mode 100644
index 00000000..e97fa5d7
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ExtendedLinearExpressionBuilderFactory.xtend
@@ -0,0 +1,140 @@
+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.logic.model.logiclanguage.Type
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.HashSet
+import java.util.List
+import java.util.Map
+import java.util.Set
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+interface BoundSaturationListener {
+        def void boundsSaturated(Integer lower, Integer upper)
+}
+
+interface ExtendedLinearExpressionBuilderFactory {
+        def ExtendedLinearExpressionBuilder createBuilder()
+
+        def Dimension getDimension(IPatternMatch patternMatch)
+}
+
+interface ExtendedLinearExpressionBuilder extends LinearTypeExpressionBuilder {
+        override ExtendedLinearExpressionBuilder add(int scale, Type type)
+
+        def ExtendedLinearExpressionBuilder add(int scale, IPatternMatch patternMatch)
+
+        def ExtendedLinearExpressionBuilder add(int scale, Dimension dimension)
+
+        def LinearBoundedExpression build(BoundSaturationListener listener)
+}
+
+class ExtendedPolyhedronBuilder implements ExtendedLinearExpressionBuilderFactory {
+        val Map<Type, LinearBoundedExpression> typeBounds
+        val Map<Map<Dimension, Integer>, LinearBoundedExpression> expressionsCache
+
+        val ImmutableList.Builder<Dimension> dimensions = ImmutableList.builder
+        val Set<LinearConstraint> constraints = new HashSet
+        val Set<LinearBoundedExpression> expressionsToSaturate = new HashSet
+        val Map<IPatternMatch, Dimension> patternMatchCounts = new HashMap
+        @Accessors(PUBLIC_GETTER) val List<Pair<LinearBoundedExpression, BoundSaturationListener>> saturationListeners = new ArrayList
+
+        new(Polyhedron polyhedron, Map<Type, LinearBoundedExpression> typeBounds,
+                Map<Map<Dimension, Integer>, LinearBoundedExpression> initialExpressionsCache) {
+                this.typeBounds = typeBounds
+                this.expressionsCache = new HashMap(initialExpressionsCache)
+                dimensions.addAll(polyhedron.dimensions)
+                constraints.addAll(polyhedron.constraints)
+                expressionsToSaturate.addAll(polyhedron.expressionsToSaturate)
+        }
+
+        override createBuilder() {
+                new ExtendedLinearExpressionBuilderImpl(this)
+        }
+
+        override getDimension(IPatternMatch patternMatch) {
+                patternMatchCounts.computeIfAbsent(patternMatch) [ key |
+                        val dimension = new Dimension(key.toString, 0, null)
+                        dimensions.add(dimension)
+                        dimension
+                ]
+        }
+
+        def buildPolyhedron() {
+                new Polyhedron(
+                        dimensions.build,
+                        ImmutableList.copyOf(constraints),
+                        ImmutableList.copyOf(expressionsToSaturate)
+                )
+        }
+
+        @FinalFieldsConstructor
+        private static class ExtendedLinearExpressionBuilderImpl implements ExtendedLinearExpressionBuilder {
+                val ExtendedPolyhedronBuilder polyhedronBuilder
+
+                val Map<Dimension, Integer> coefficients = new HashMap
+
+                override add(int scale, Type type) {
+                        val expression = polyhedronBuilder.typeBounds.get(type)
+                        if (expression === null) {
+                                throw new IllegalArgumentException("Unknown Type: " + type)
+                        }
+                        add(scale, expression)
+                }
+
+                override add(int scale, IPatternMatch patternMatch) {
+                        val dimension = polyhedronBuilder.getDimension(patternMatch)
+                        add(scale, dimension)
+                }
+
+                private def add(int scale, LinearBoundedExpression expression) {
+                        switch (expression) {
+                                Dimension: add(scale, expression)
+                                LinearConstraint: add(scale, expression.coefficients)
+                                default: throw new IllegalArgumentException("Unknown LinearBoundedExpression: " + expression)
+                        }
+                }
+
+                private def add(int scale, Map<Dimension, Integer> coefficients) {
+                        for (pair : coefficients.entrySet) {
+                                add(scale * pair.value, pair.key)
+                        }
+                        this
+                }
+
+                override add(int scale, Dimension dimension) {
+                        coefficients.merge(dimension, scale)[a, b|a + b]
+                        this
+                }
+
+                override build() {
+                        val filteredCoefficients = ImmutableMap.copyOf(coefficients.filter [ x, coefficient |
+                                coefficient != 0
+                        ])
+                        polyhedronBuilder.expressionsCache.computeIfAbsent(filteredCoefficients) [ map |
+                                if (map.size == 1) {
+                                        val pair = map.entrySet.head
+                                        if (pair.value == 1) {
+                                                return pair.key
+                                        }
+                                }
+                                val constraint = new LinearConstraint(map)
+                                polyhedronBuilder.constraints.add(constraint)
+                                constraint
+                        ]
+                }
+
+                override build(BoundSaturationListener listener) {
+                        val expression = build()
+                        if (listener !== null) {
+                                polyhedronBuilder.expressionsToSaturate.add(expression)
+                                polyhedronBuilder.saturationListeners.add(expression -> listener)
+                        }
+                        expression
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ExtendedPolyhedronScopePropagatorStrategy.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ExtendedPolyhedronScopePropagatorStrategy.xtend
new file mode 100644
index 00000000..32923396
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ExtendedPolyhedronScopePropagatorStrategy.xtend
@@ -0,0 +1,63 @@
+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.ModelGenerationStatistics
+import java.util.Collection
+import java.util.Map
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
+
+interface PolyhedronExtensionOperator {
+        def void extendPolyhedron(ExtendedLinearExpressionBuilderFactory factory)
+}
+
+class ExtendedPolyhedronScopePropagatorStrategy extends PolyhedronScopePropagatorStrategy {
+        val PolyhedronSolver solver
+        val Collection<PolyhedronExtensionOperator> extensionOperators
+
+        var Map<Type, LinearBoundedExpression> typeBounds
+        var Map<Map<Dimension, Integer>, LinearBoundedExpression> initialExpressionsCache
+
+        new(PolyhedronSolver solver, Collection<PolyhedronExtensionOperator> extensionOperators,
+                ModelGenerationStatistics statistics) {
+                super(statistics)
+                this.solver = solver
+                this.extensionOperators = extensionOperators
+        }
+
+        override setPolyhedron(Polyhedron polyhedron, Map<Type, LinearBoundedExpression> typeBounds,
+                Map<Map<Dimension, Integer>, LinearBoundedExpression> initialExpressionsCache) {
+                super.setPolyhedron(polyhedron, typeBounds, initialExpressionsCache)
+                this.typeBounds = typeBounds
+                this.initialExpressionsCache = initialExpressionsCache
+        }
+
+        override isRelevantRelation(Relation relation) {
+                true
+        }
+
+        override protected doSaturate() {
+                val builder = new ExtendedPolyhedronBuilder(polyhedron, typeBounds, initialExpressionsCache)
+                for (extensionOperator : extensionOperators) {
+                        extensionOperator.extendPolyhedron(builder)
+                }
+                val extendedPolyhedron = builder.buildPolyhedron()
+                val saturationOperator = solver.createSaturationOperator(extendedPolyhedron)
+                val result = try {
+                                saturationOperator.saturate()
+                        } finally {
+                                saturationOperator.close()
+                        }
+                if (result == PolyhedronSaturationResult.EMPTY) {
+                        // The partial model cannot be refined any more, we can't provide objective bounds.
+                        for (pair : builder.saturationListeners) {
+                                pair.value.boundsSaturated(null, null)
+                        }
+                        return false
+                }
+                for (pair : builder.saturationListeners) {
+                        val expression = pair.key
+                        pair.value.boundsSaturated(expression.lowerBound, expression.upperBound)
+                }
+                true
+        }
+}
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..31f98e36
--- /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,32 @@
+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 java.util.Map
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
+
+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, Map<String, PQuery> fqnToPQuery)
+        
+        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/cardinality/MultiplicityGoalConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/MultiplicityGoalConstraintCalculator.xtend
new file mode 100644
index 00000000..273e0ac3
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/MultiplicityGoalConstraintCalculator.xtend
@@ -0,0 +1,57 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality

+

+import org.eclipse.emf.common.notify.Notifier

+import org.eclipse.viatra.query.runtime.api.IQuerySpecification

+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine

+import org.eclipse.viatra.query.runtime.emf.EMFScope

+

+class MultiplicityGoalConstraintCalculator {

+        val String targetRelationName

+        val IQuerySpecification<?> querySpecification

+        var MultiplicityCalculator<?> calculator

+        val boolean containment

+        val int lowerBound

+        val int cost

+                

+        new(String targetRelationName, IQuerySpecification<?> querySpecification, boolean containment, int lowerBound, int cost) {

+                if (lowerBound <= 0) {

+                        throw new IllegalArgumentException("Invalid lower bound: " + lowerBound)

+                }

+                this.targetRelationName = targetRelationName

+                this.querySpecification = querySpecification

+                this.calculator = null

+                this.containment = containment

+                this.lowerBound = lowerBound

+                this.cost = cost

+        }

+        

+        new(MultiplicityGoalConstraintCalculator other) {

+                this.targetRelationName = other.targetRelationName

+                this.querySpecification = other.querySpecification

+                this.calculator = null

+                this.containment = other.containment

+                this.lowerBound = other.lowerBound

+                this.cost = other.cost

+        }

+        

+        def getName() {

+                targetRelationName

+        }

+        

+        def isContainment() {

+                return containment

+        }

+

+        def init(Notifier notifier) {

+                val engine = ViatraQueryEngine.on(new EMFScope(notifier))

+                val matcher = querySpecification.getMatcher(engine)

+                calculator = RemainingMultiplicityCalculator.of(matcher, lowerBound)

+        }

+        

+        def calculateValue() {

+                val res = calculator.multiplicity

+//              if(res>0)

+//              println(targetRelationName+ " all missing multiplicities: "+res + "*"+cost+"="+res*cost)

+                return res*cost

+        }

+}
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..ad8f94ab
--- /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,522 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+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 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 {
+        val boolean updateHeuristic
+        val Map<Scope, LinearBoundedExpression> scopeBounds
+        val LinearBoundedExpression topLevelBounds
+        val Polyhedron polyhedron
+        val PolyhedronScopePropagatorStrategy strategy
+        val Set<Relation> relevantRelations
+        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, PolyhedronScopePropagatorStrategy strategy,
+                boolean propagateRelations, boolean updateHeuristic) {
+                super(p, statistics)
+                this.updateHeuristic = updateHeuristic
+                this.strategy = strategy
+                val builder = new PolyhedronBuilder(p)
+                builder.buildPolyhedron(possibleNewDynamicTypes)
+                scopeBounds = builder.scopeBounds
+                topLevelBounds = builder.topLevelBounds
+                polyhedron = builder.polyhedron
+                strategy.setPolyhedron(polyhedron, builder.typeBounds, builder.expressionsCache)
+                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)
+                if (strategy.saturate) {
+                        populateScopesFromPolyhedron()
+                } else {
+                        setScopesInvalid()
+                }
+//              println(polyhedron)
+                if (updateHeuristic) {
+                        copyScopeBoundsToHeuristic()
+                }
+        }
+
+        override isPropagationNeededAfterAdditionToRelation(Relation r) {
+                relevantRelations.contains(r) || strategy.isRelevantRelation(r) || super.isPropagationNeededAfterAdditionToRelation(r)
+        }
+
+        override isQueryEngineFlushRequiredBeforePropagation() {
+                true
+        }
+
+        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)
+                }
+        }
+
+        @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 = if (maximumNuberOfNewNodes <= Integer.MAX_VALUE / INFINITY_SCALE) {
+                                maximumNuberOfNewNodes * INFINITY_SCALE
+                        } else {
+                                Integer.MAX_VALUE
+                        }
+
+                        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 && !constraint.container) {
+                                        buildNonContainmentConstraints(constraint, pair.value)
+                                }
+                        }
+                        buildRelevantRelations(constraints.keySet)
+                        for (hint : hints) {
+                                val updater = hint.createConstraintUpdater(this)
+                                if (updater !== null) {
+                                        updatersBuilder.add(updater)
+                                }
+                        }
+                        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 unfinishedMultiplicitiesBuilder = ImmutableList.builder
+                        val remainingContentsBuilder = 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 (queries.existingMultiplicityQuery !== null) {
+                                        val matcher = queries.existingMultiplicityQuery.getMatcher(queryEngine)
+                                        if (constraint.constrainsUnfinished) {
+                                                unfinishedMultiplicitiesBuilder.add(
+                                                        RemainingMultiplicityCalculator.of(matcher, constraint.lowerBound))
+                                        }
+                                        remainingContentsBuilder.add(RemainingMultiplicityCalculator.of(matcher, constraint.upperBound))
+                                } else if (constraint.constrainsUnfinished) {
+                                        throw new IllegalArgumentException("Containment constraints need multiplicity queries")
+                                }
+                        }
+                        val orphanLowerBound = orphansLowerBoundCoefficients.toExpression
+                        val orphanUpperBound = orphansUpperBoundCoefficients.toExpression
+                        val updater = new ContainmentConstraintUpdater(orphanLowerBound, orphanUpperBound,
+                                unfinishedMultiplicitiesBuilder.build, remainingContentsBuilder.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.reference) {
+                                return
+                        }
+                        if (constraint.constrainsRemainingInverse) {
+                                if (queries.getExistingMultiplicityQuery === null) {
+                                        throw new IllegalArgumentException("Reference constraints need unfinished multiplicity queries: " +
+                                                constraint.relation)
+                                }
+                                val existingMultiplicityMatcher = queries.getExistingMultiplicityQuery.getMatcher(queryEngine)
+                                val unfinishedMultiplicityCalculator = RemainingMultiplicityCalculator.of(existingMultiplicityMatcher,
+                                        constraint.lowerBound)
+                                val existingInverseMultiplicityMatcher = queries.existingInverseMultiplicityQuery.getMatcher(
+                                        queryEngine)
+                                val remainingInverseMultiplicityCalculator = new RemainingInverseMultiplicityCalculator(
+                                        existingInverseMultiplicityMatcher, constraint.upperBound)
+                                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(availableMultiplicity, unfinishedMultiplicityCalculator,
+                                                remainingInverseMultiplicityCalculator))
+                        }
+                        if (constraint.constrainsUnrepairable) {
+                                if (queries.existingMultiplicityQuery.parameters.size < 5) {
+                                        throw new IllegalArgumentException("Reference constraints need repairable multiplicity queries: " +
+                                                constraint.relation)
+                                }
+                                val matcher = queries.existingMultiplicityQuery.getMatcher(queryEngine)
+                                val calculator = new UnrepairableMultiplicityCalculator(matcher, constraint.lowerBound)
+                                val targetTypeCardinality = typeBounds.get(constraint.targetType)
+                                updatersBuilder.add(new UnrepairableMultiplicityConstraintUpdater(targetTypeCardinality, calculator))
+                        }
+                }
+
+                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 IllegalStateException("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 LinearBoundedExpression orphansLowerBound
+                val LinearBoundedExpression orphansUpperBound
+                val List<MultiplicityCalculator<? extends IPatternMatch>> unfinishedMultiplicities
+                val List<MultiplicityCalculator<? extends IPatternMatch>> remainingContents
+
+                override update(PartialInterpretation p) {
+                        tightenLowerBound(p)
+                        tightenUpperBound(p)
+                }
+
+                private def tightenLowerBound(PartialInterpretation p) {
+                        var int sum = 0
+                        for (calculator : remainingContents) {
+                                val value = calculator.getMultiplicity(p)
+                                if (value < 0) {
+                                        // Infinite upper bound, no need to tighten.
+                                        return
+                                }
+                                sum += value
+                        }
+                        orphansLowerBound.tightenUpperBound(sum)
+                }
+
+                private def tightenUpperBound(PartialInterpretation p) {
+                        var int sum = 0
+                        for (calculator : unfinishedMultiplicities) {
+                                val value = calculator.getMultiplicity(p)
+                                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 LinearBoundedExpression availableMultiplicityExpression
+                val MultiplicityCalculator<? extends IPatternMatch> unfinishedMultiplicityCalculator
+                val MultiplicityCalculator<? extends IPatternMatch> remainingInverseMultiplcityCalculator
+
+                override update(PartialInterpretation p) {
+                        val unfinishedMultiplicity = unfinishedMultiplicityCalculator.getMultiplicity(p)
+                        val remainingInverseMultiplicity = remainingInverseMultiplcityCalculator.getMultiplicity(p)
+                        val int requiredMultiplicity = unfinishedMultiplicity - remainingInverseMultiplicity
+                        availableMultiplicityExpression.tightenLowerBound(requiredMultiplicity)
+                }
+        }
+
+        @FinalFieldsConstructor
+        private static class UnrepairableMultiplicityConstraintUpdater implements RelationConstraintUpdater {
+                val LinearBoundedExpression targetCardinalityExpression
+                val MultiplicityCalculator<? extends IPatternMatch> calculator
+
+                override update(PartialInterpretation p) {
+                        val value = calculator.getMultiplicity(p)
+                        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/PolyhedronScopePropagatorStrategy.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronScopePropagatorStrategy.xtend
new file mode 100644
index 00000000..f93dcd18
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronScopePropagatorStrategy.xtend
@@ -0,0 +1,92 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import com.google.common.cache.Cache
+import com.google.common.cache.CacheBuilder
+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 java.util.Map
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+@FinalFieldsConstructor
+abstract class PolyhedronScopePropagatorStrategy {
+        val ModelGenerationStatistics statistics
+
+        @Accessors(PUBLIC_GETTER) var Polyhedron polyhedron
+
+        def void setPolyhedron(Polyhedron polyhedron, Map<Type, LinearBoundedExpression> typeBounds,
+                Map<Map<Dimension, Integer>, LinearBoundedExpression> initialExpressionsCache) {
+                if (this.polyhedron !== null) {
+                        throw new IllegalStateException("polyhedron was already set")
+                }
+                this.polyhedron = polyhedron
+                initialize()
+        }
+
+        def boolean saturate() {
+                if (polyhedron === null) {
+                        throw new IllegalStateException("polyhedron was not set")
+                }
+                doSaturate()
+        }
+        
+        def boolean isRelevantRelation(Relation relation) {
+                false
+        }
+
+        protected def incrementScopePropagationSolverCount() {
+                statistics.incrementScopePropagationSolverCount()
+        }
+
+        protected def void initialize() {
+        }
+
+        protected def boolean doSaturate()
+}
+
+@FinalFieldsConstructor
+class CachingSimplePolyhedronScopePropagatorStrategy extends PolyhedronScopePropagatorStrategy {
+        static val CACHE_SIZE = 10000
+
+        val PolyhedronSolver solver
+
+        val Cache<PolyhedronSignature, PolyhedronSignature> cache = CacheBuilder.newBuilder.maximumSize(CACHE_SIZE).build
+        var PolyhedronSaturationOperator operator
+
+        new(PolyhedronSolver solver, ModelGenerationStatistics statistics) {
+                super(statistics)
+                this.solver = solver
+        }
+
+        override protected initialize() {
+                operator = solver.createSaturationOperator(polyhedron)
+        }
+
+        override protected doSaturate() {
+                val signature = polyhedron.createSignature
+                val cachedSignature = cache.getIfPresent(signature)
+                switch (cachedSignature) {
+                        case null: {
+                                incrementScopePropagationSolverCount()
+                                val result = operator.saturate()
+                                if (result == PolyhedronSaturationResult.EMPTY) {
+                                        cache.put(signature, PolyhedronSignature.EMPTY)
+                                        false
+                                } else {
+                                        val resultSignature = polyhedron.createSignature
+                                        cache.put(signature, resultSignature)
+                                        true
+                                }
+                        }
+                        case PolyhedronSignature.EMPTY:
+                                false
+                        PolyhedronSignature.Bounds: {
+                                polyhedron.applySignature(signature)
+                                true
+                        }
+                        default:
+                                throw new IllegalStateException("Unknown polyhedron signature: " + signature)
+                }
+        }
+}
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..21bd2d9e
--- /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,186 @@
+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
+class Bounds {
+        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 assertBetween(Integer tighterLowerBound, Integer tighterUpperBound) {
+                tightenLowerBound(tighterLowerBound)
+                tightenUpperBound(tighterUpperBound)
+        }
+
+        def void assertEqualsTo(int bound) {
+                assertBetween(bound, bound)
+        }
+}
+
+abstract class LinearBoundedExpression extends Bounds {
+}
+
+@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..abf65be3
--- /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,156 @@
+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.
+                false && constrainsUnfinished && canHaveMultipleSourcesPerTarget && reference
+        }
+
+        def constrainsRemainingInverse() {
+                lowerBound >= 1 && !containment && !container && inverseUpperBoundFinite && reference
+        }
+
+        def constrainsRemainingContents() {
+                containment
+        }
+
+        def isActive() {
+                constrainsUnfinished || constrainsUnrepairable || constrainsRemainingInverse || constrainsRemainingContents
+        }
+
+        def isSourceTypeComplex() {
+                getParamTypeReference(0) instanceof ComplexTypeReference
+        }
+        
+        def isTargetTypeComplex() {
+                getParamTypeReference(1) instanceof ComplexTypeReference
+        }
+        
+        def isReference() {
+                sourceTypeComplex && targetTypeComplex
+        }
+
+        def getSourceType() {
+                getParamType(0)
+        }
+
+        def getTargetType() {
+                getParamType(1)
+        }
+
+        private def getParamTypeReference(int i) {
+                val parameters = relation.parameters
+                if (i < parameters.size) {
+                        return parameters.get(i)
+                }
+                throw new IllegalArgumentException("Argument index out of range")
+        }
+        
+        private def getParamType(int i) {
+                val reference = getParamTypeReference(i)
+                if (reference instanceof ComplexTypeReference) {
+                        return reference.referred
+                }
+                throw new IllegalArgumentException("Constraint with primitive 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/RemainingMultiplicityCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/RemainingMultiplicityCalculator.xtend
new file mode 100644
index 00000000..48b52d28
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/RemainingMultiplicityCalculator.xtend
@@ -0,0 +1,111 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import java.util.Iterator
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+@FinalFieldsConstructor
+abstract class MultiplicityCalculator<Match extends IPatternMatch> {
+        val ViatraQueryMatcher<Match> matcher
+
+        def getMultiplicity() {
+                val iterator = matcher.streamAllMatches.iterator
+                getMultiplicity(iterator)
+        }
+        
+        def getMultiplicity(PartialInterpretation interpretation) {
+                val partialMatch = matcher.newEmptyMatch
+                partialMatch.set(0, interpretation.problem)
+                partialMatch.set(1, interpretation)
+                val iterator = matcher.streamAllMatches(partialMatch).iterator
+                getMultiplicity(iterator)
+        }
+
+        protected def int getMultiplicity(Iterator<? extends Match> iterator)
+}
+
+class RemainingMultiplicityCalculator<Match extends IPatternMatch> extends MultiplicityCalculator<Match> {
+        val int bound
+
+        @FinalFieldsConstructor
+        private new() {
+        }
+
+        protected override getMultiplicity(Iterator<? extends Match> iterator) {
+                var res = 0
+                while (iterator.hasNext) {
+                        val match = iterator.next
+                        val existingMultiplicity = match.get(3) as Integer
+                        if (existingMultiplicity < bound) {
+                                res += bound - existingMultiplicity
+                        }
+                }
+                res
+        }
+        
+        static def <Match extends IPatternMatch> of(ViatraQueryMatcher<Match> matcher, int bound) {
+                if (bound < 0) {
+                        new RemainingInfiniteMultiplicityCalculator(matcher)
+                } else {
+                        new RemainingMultiplicityCalculator(matcher, bound)
+                }
+        }
+}
+
+package class RemainingInfiniteMultiplicityCalculator<Match extends IPatternMatch> extends MultiplicityCalculator<Match> {
+        
+        @FinalFieldsConstructor
+        package new() {
+        }
+        
+        protected override getMultiplicity(Iterator<? extends Match> iterator) {
+                if (iterator.hasNext) {
+                        -1
+                } else {
+                        0
+                }
+        }
+}
+
+@FinalFieldsConstructor
+class UnrepairableMultiplicityCalculator<Match extends IPatternMatch> extends MultiplicityCalculator<Match> {
+        val int lowerBound
+        
+        override protected getMultiplicity(Iterator<? extends Match> iterator) {
+                var res = 0
+                while (iterator.hasNext) {
+                        val match = iterator.next
+                        val existingMultiplicity = match.get(3) as Integer
+                        if (existingMultiplicity < lowerBound) {
+                                val missingMultiplcity = lowerBound - existingMultiplicity
+                                val numerOfRepairMatches = match.get(4) as Integer
+                                val unrepairableMultiplicty = missingMultiplcity - numerOfRepairMatches
+                                if (unrepairableMultiplicty > res) {
+                                        res = unrepairableMultiplicty
+                                }
+                        }
+                }
+                res
+        }
+}
+
+@FinalFieldsConstructor
+class RemainingInverseMultiplicityCalculator<Match extends IPatternMatch> extends MultiplicityCalculator<Match> {
+        val int upperBound
+        
+        override protected getMultiplicity(Iterator<? extends Match> iterator) {
+                var res = 0
+                while (iterator.hasNext) {
+                        val match = iterator.next
+                        val existingMultiplicity = match.get(3) as Integer
+                        if (existingMultiplicity < upperBound) {
+                                val availableMultiplicity = upperBound - existingMultiplicity
+                                val numberOfRepairMatches = match.get(4) as Integer
+                                res += Math.min(availableMultiplicity, numberOfRepairMatches)
+                        }
+                }
+                res
+        }
+}
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..cacba3c6
--- /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,161 @@
+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.PartialPrimitiveInterpretation

+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

+        

+        @Accessors(PUBLIC_GETTER) var scopePropagationNeeded = false

+

+        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 void propagateAllScopeConstraints() {

+                scopePropagationNeeded = false

+                if (!valid) {

+                        return

+                }

+                statistics.incrementScopePropagationCount()

+                doPropagateAllScopeConstraints()

+        }

+

+        def isValid() {

+                partialInterpretation.maxNewElements == -1 ||

+                        partialInterpretation.minNewElements <= partialInterpretation.maxNewElements

+        }

+

+        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) {

+                val isPrimitive = t instanceof PartialPrimitiveInterpretation || t === null

+                if (isPrimitive) {

+                        return

+                }

+                scopePropagationNeeded = true

+//              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»''')

+        }

+        

+        def addedToRelation(Relation r) {

+                if (isPropagationNeededAfterAdditionToRelation(r)) {

+                        scopePropagationNeeded = true

+                }

+        }

+

+        protected def setScopesInvalid() {

+                partialInterpretation.minNewElements = Integer.MAX_VALUE

+                partialInterpretation.maxNewElements = 0

+                for (scope : partialInterpretation.scopes) {

+                        scope.minNewElements = Integer.MAX_VALUE

+                        scope.maxNewElements = 0

+                }

+        }

+

+        protected def isPropagationNeededAfterAdditionToRelation(Relation r) {

+                false

+        }

+        

+        def isQueryEngineFlushRequiredBeforePropagation() {

+                false

+        }

+

+        private def removeOne(Scope scope) {

+                if (scope.minNewElements > 0) {

+                        scope.minNewElements = scope.minNewElements - 1

+                }

+                if (scope.minNewElementsHeuristic > 0) {

+                        scope.minNewElementsHeuristic = scope.minNewElementsHeuristic - 1

+                }

+                if (scope.maxNewElements > 0) {

+                        scope.maxNewElements = scope.maxNewElements - 1

+                } else if (scope.maxNewElements === 0) {

+                        setScopesInvalid()

+                }

+        }

+}

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/formulacanonization/CanonisedFormulae.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/formulacanonization/CanonisedFormulae.xtend
index e511a961..fd4374f5 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/formulacanonization/CanonisedFormulae.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/formulacanonization/CanonisedFormulae.xtend
@@ -11,7 +11,5 @@ import org.eclipse.xtend.lib.annotations.Data
 class CanonisedFormulae {

         CharSequence viatraCode

         Map<Assertion,String> assertion2ConstraintPattern

-        Map<ConstantDefinition,String> constant2ValuePattern

         Map<RelationDefinition,String> relation2ValuePattern

-        Map<FunctionDefinition,String> function2ValuePattern

 }
\ 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/formulacanonization/FormulaCanoniser.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/formulacanonization/FormulaCanoniser.xtend
index 0af0b36a..182f3a3a 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/formulacanonization/FormulaCanoniser.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/formulacanonization/FormulaCanoniser.xtend
@@ -5,17 +5,35 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDefinition
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.FunctionDefinition

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition

 import java.util.List

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Term

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicValue

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Variable

 

 /**

- * Translates a set of assertions and definitions to viatra patterns.

+ * Translates a Terms into format

+ * <P(x1,...,xn)> := Bodies(x1,...,xn)

+ * <Bodies(x1,...,xn)> := <Body(x1,...,xn)> | <Body(x1,...,xn)> or <Bodies(x1,...,xn)>

+ * <Body(x1,...,xn)> := Exists y1,...,ym : <Constraints(x1,...,xn,y1,....,ym)>

+ * <Constraints(x1,...,xn)> := Constraint(x1,...xn) | Constraint(x1,...,xn) and <Constraints(x1,...,xn)>   

  */

 class FormulaCanoniser {

-        def canonise(

-                List<Assertion> assertions,

-                List<RelationDefinition> relations,

-                List<ConstantDefinition> constants,

-                List<FunctionDefinition> functions)

-        {

-                

-        }

+//      def canonise(

+//              List<Assertion> assertions,

+//              List<RelationDefinition> relations)

+//      {

+//              

+//      }

+//      

+//      

+//      def canoniseToConstraintBlock(Term predicate, List<Variable> variables) {

+//              val 

+//      }

+//      

+//      def freeVariables(Term t) {

+//              val subterms = #[t]+t.eAllContents.toList

+//              val variables = subterms.filter(Variable).toSet

+//              val variableReferences = subterms.filter(SymbolicValue).filter[it.symbolicReference instanceof Variable]

+//              val freeVariables = variableReferences.filter[!variables.contains(it.symbolicReference)]

+//              return freeVariables.map

+//      }

 }
\ 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/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() '''

-        private pattern newELement(interpretation: PartialInterpretation, element: DefinedElement) {

-                PartialInterpretation.newElements(interpretation,element);

-        }

-        

-        private pattern typeInterpretation(problem:LogicProblem, interpetation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) {

-                find interpretation(problem,interpetation);

-                LogicProblem.types(problem,type);

-                PartialInterpretation.partialtypeinterpratation(interpetation,typeInterpretation);

-                PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type);

-        }

-        

-        private pattern directInstanceOf(problem:LogicProblem, interpetation:PartialInterpretation, element:DefinedElement, type:Type) {

-                find interpretation(problem,interpetation);

-                find mustExist(problem,interpetation,element);

-                LogicProblem.types(problem,type);

-                TypeDefinition.elements(type,element);

-        } or {

-                find mustExist(problem,interpetation,element);

-                find typeInterpretation(problem,interpetation,type,typeInterpretation);

-                PartialComplexTypeInterpretation.elements(typeInterpretation,element);

-        }

-        

-        /**

-         * Direct supertypes of a type.

-         */

-        private pattern supertypeDirect(subtype : Type, supertype : Type) {

-                Type.supertypes(subtype, supertype);

-        }

-        

-        /**

-         * 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

+

+        override getRequiredQueries() '''

+                «super.requiredQueries»

+                

+                /**

+                 * Direct supertypes of a type.

+                 */

+                private pattern supertypeDirect(subtype : Type, supertype : Type) {

+                        Type.supertypes(subtype, supertype);

+                }

+                

+                /**

+                 * 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

-                Type.isAbstract(dynamic,false);

-                // 5. element is not primitive datatype

-                neg find isPrimitive(element);

-        }

-        

-        /**

-         * supertype -------> element <------- otherSupertype

-         *     A                                     A

-         *     |                                     |

-         * wrongDynamic -----------------------------X

-         */

-        private pattern dynamicTypeNotSubtypeOfADefinition(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, wrongDynamic : Type) {

-                find directInstanceOf(problem,interpretation,element,supertype);

-                find directInstanceOf(problem,interpretation,element,otherSupertype);

-                find supertypeStar(wrongDynamic,supertype);

-                neg find supertypeStar(wrongDynamic,otherSupertype);

-        }

-        

-        /**

-         * supertype -------> element <---X--- otherSupertype

-         *     A                                     A

-         *     |                                     |

-         * wrongDynamic -----------------------------+

-         */

-        private pattern dynamicTypeIsSubtypeOfANonDefinition(problem: LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, wrongDynamic:Type) {

-                find directInstanceOf(problem,interpretation,element,supertype);

-                neg find elementInTypeDefinition(element,otherSupertype);

-                TypeDefinition(otherSupertype);

-                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);

-        }

-        '''

-        

-        public override generateInstanceOfQueries(LogicProblem problem, PartialInterpretation emptySolution,TypeAnalysisResult typeAnalysisResult) {

-                '''

-                «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) {

-                '''

+                // 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 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);

+                        // 5. element is not primitive datatype

+                        neg find isPrimitive(element);

+                }

+                

                 /**

-                 * 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) {

-                        Type.name(type,"«type.name»");

-                        find directInstanceOf(problem,interpretation,element,type);

+                private pattern dynamicTypeNotSubtypeOfADefinition(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, wrongDynamic : Type) {

+                        find directInstanceOf(problem,interpretation,element,supertype);

+                        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) {

-                        Type.name(type,"«type.name»");

-                        find possibleDynamicType(problem,interpretation,dynamic,element);

-                        find supertypeStar(dynamic,type);

-                        neg find scopeDisallowsNewElementsFromType(dynamic);

+                private pattern dynamicTypeIsSubtypeOfANonDefinition(problem: LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, wrongDynamic:Type) {

+                        find directInstanceOf(problem,interpretation,element,supertype);

+                        neg find elementInTypeDefinition(element,otherSupertype);

+                        TypeDefinition(otherSupertype);

+                        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[

-                        inverseRelations.put(it.inverseA,it.inverseB)

-                        inverseRelations.put(it.inverseB,it.inverseA)

+                p.annotations.filter(InverseRelationAssertion).forEach [

+                        inverseRelations.put(it.inverseA, it.inverseB)

+                        inverseRelations.put(it.inverseB, it.inverseA)

                 ]

                 return '''

-                private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation)

-                «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)

-                                {

+                        pattern «hasElementInContainmentName»(problem:LogicProblem, interpretation:PartialInterpretation)

+                        «FOR type : containment.typesOrderedInHierarchy SEPARATOR "or"»{

                                         find interpretation(problem,interpretation);

-                                        neg find hasElementInContainment(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»

+                                        «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  «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]»

-                        pattern refineTypeTo_«base.canonizeName(type.name)»(problem:LogicProblem, interpretation:PartialInterpretation, object: DefinedElement) {

-                                find interpretation(problem,interpretation);

-                                find mustExist(problem, interpretation, object);

-                                «base.typeIndexer.referInstanceOf(type,Modality.MAY,"object")»

-                                neg «base.typeIndexer.referInstanceOf(type,Modality.MUST,"object")»

-                        }

-                «ENDFOR»

+                        «FOR type : p.types.filter(TypeDeclaration).filter[!it.isAbstract]»

+                                pattern refineTypeTo_«base.canonizeName(type.name)»(problem:LogicProblem, interpretation:PartialInterpretation, object: DefinedElement) {

+                                        find interpretation(problem,interpretation);

+                                        find mustExist(problem, interpretation, object);

+                                        «base.typeIndexer.referInstanceOf(type,Modality.MAY,"object")»

+                                        neg «base.typeIndexer.referInstanceOf(type,Modality.MUST,"object")»

+                                }

+                        «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/PConstraintTransformer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend
new file mode 100644
index 00000000..dd5cade1
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend
@@ -0,0 +1,275 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

+

+import hu.bme.mit.inf.dslreasoner.viatra2logic.XExpressionExtractor

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality

+import org.eclipse.emf.ecore.EAttribute

+import org.eclipse.emf.ecore.EEnumLiteral

+import org.eclipse.emf.ecore.EReference

+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey

+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey

+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey

+import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint

+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExpressionEvaluation

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint

+import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.VariableMapping

+import java.util.List

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeReference

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.PrimitiveTypeReference

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.StringTypeReference

+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

+import java.util.Map

+

+class PConstraintTransformer {

+        val extension RelationDefinitionIndexer relationDefinitionIndexer;

+        val expressionExtractor = new XExpressionExtractor

+        val expressionGenerator = new PExpressionGenerator

+        

+        new(RelationDefinitionIndexer relationDefinitionIndexer) {

+                this.relationDefinitionIndexer = relationDefinitionIndexer

+        }

+        

+        dispatch def transformConstraint(TypeConstraint constraint, Modality modality, List<VariableMapping> variableMapping) {

+                val touple = constraint.variablesTuple

+                if(touple.size == 1) {

+                        val inputKey = constraint.equivalentJudgement.inputKey

+                        if(inputKey instanceof EClassTransitiveInstancesKey) {

+                                return relationDefinitionIndexer.base.typeIndexer.referInstanceOf(inputKey.emfKey,modality.toMustMay,

+                                        constraint.getVariableInTuple(0).canonizeName)

+                        } else if(inputKey instanceof EDataTypeInSlotsKey){

+                                return '''// type constraint is enforced by construction'''

+                        }

+                        

+                } else if(touple.size == 2){

+                        val key = (constraint.equivalentJudgement.inputKey as EStructuralFeatureInstancesKey).emfKey

+                        if(key instanceof EReference) {

+                                return base.referRelationByName(

+                                        key,

+                                        constraint.getVariableInTuple(0).canonizeName,

+                                        constraint.getVariableInTuple(1).canonizeName,

+                                        modality.toMustMay)

+                        } else if (key instanceof EAttribute) {

+                                return base.referAttributeByName(key,

+                                        constraint.getVariableInTuple(0).canonizeName,

+                                        constraint.getVariableInTuple(1).canonizeName,

+                                        modality.toMustMay)

+                        } else throw new UnsupportedOperationException('''unknown key: «key.class»''')

+                } else {

+                        throw new UnsupportedOperationException('''Unsupported touple size: «touple.size»''')

+                }

+        }

+        dispatch def transformConstraint(TypeFilterConstraint constraint, Modality modality, List<VariableMapping> variableMapping) {

+                val touple = constraint.variablesTuple

+                if(touple.size == 1) {

+                        val inputKey = constraint.equivalentJudgement.inputKey

+                        if(inputKey instanceof EClassTransitiveInstancesKey) {

+                                return base.typeIndexer.referInstanceOf(inputKey.emfKey,modality.toMustMay,

+                                        (constraint.getVariablesTuple.get(0) as PVariable).canonizeName)

+                        } else if(inputKey instanceof EDataTypeInSlotsKey){

+                                return '''// type constraint is enforced by construction'''

+                        }

+                        

+                } else if(touple.size == 2){

+                        val key = (constraint.equivalentJudgement.inputKey as EStructuralFeatureInstancesKey).emfKey

+                        if(key instanceof EReference) {

+                                return base.referRelationByName(

+                                        key,

+                                        (constraint.getVariablesTuple.get(0) as PVariable).canonizeName,

+                                        (constraint.getVariablesTuple.get(1) as PVariable).canonizeName,

+                                        modality.toMustMay)

+                        } else if (key instanceof EAttribute) {

+                                return base.referAttributeByName(key,

+                                        (constraint.getVariablesTuple.get(0) as PVariable).canonizeName,

+                                        (constraint.getVariablesTuple.get(1) as PVariable).canonizeName,

+                                        modality.toMustMay)

+                        } else throw new UnsupportedOperationException('''unknown key: «key.class»''')

+                } else {

+                        throw new UnsupportedOperationException('''Unsupported touple size: «touple.size»''')

+                }

+        }

+        

+        dispatch def transformConstraint(Equality equality, Modality modality, List<VariableMapping> variableMapping) {

+                val a = equality.who

+                val b = equality.withWhom

+                transformEquality(modality.toMustMay, a, b)

+        }

+        

+        private def CharSequence transformEquality(Modality modality, PVariable a, PVariable b) {

+                if(modality.isMustOrCurrent) '''find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''

+                else '''find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''

+        }       

+        

+        dispatch def transformConstraint(Inequality inequality, Modality modality, List<VariableMapping> variableMapping) {

+                val a = inequality.who

+                val b = inequality.withWhom

+                if(modality.isCurrent) {

+                        return '''neg find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''

+                } else if(modality.isMust) {

+                        return '''neg find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''

+                } else { // modality.isMay

+                        return '''neg find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''

+                }

+        }

+        

+        dispatch def transformConstraint(NegativePatternCall pcall, Modality modality, List<VariableMapping> variableMapping) {

+                val params = (0..<pcall.actualParametersTuple.size).map[index | 

+                        val variable = pcall.actualParametersTuple.get(index) as PVariable

+                        return variable.canonizeName

+                ]

+                return referPattern(pcall.referredQuery,params,modality.dual,false,false)

+        }

+        

+        dispatch def transformConstraint(PositivePatternCall pcall, Modality modality, List<VariableMapping> variableMapping) {

+                val params = (0..<pcall.variablesTuple.size).map[index | 

+                        val variable = pcall.variablesTuple.get(index) as PVariable

+                        return variable.canonizeName

+                ]

+                return referPattern(pcall.referredQuery,params,modality,true,false)

+        }

+        dispatch def transformConstraint(BinaryTransitiveClosure pcall, Modality modality, List<VariableMapping> variableMapping) {

+                val params = (0..1).map[index | 

+                        val variable = pcall.getVariableInTuple(index) as PVariable

+                        return variable.canonizeName

+                ]

+                return referPattern(pcall.referredQuery,params,modality,true,true)

+        }

+        dispatch def transformConstraint(ExportedParameter e, Modality modality, List<VariableMapping> variableMapping) {

+                val v1 = '''var_«e.parameterName»'''

+                val v2 = e.parameterVariable.canonizeName

+                if(v1.compareTo(v2) == 0) {

+                        return '''// «v1» exported'''

+                } else {

+                        return '''«v1» == «v2»;'''

+                }

+        }

+        dispatch def transformConstraint(ConstantValue c, Modality modality, List<VariableMapping> variableMapping) {

+                val target = c.supplierKey

+                

+                var String targetString;

+                var String additionalDefinition;

+                if(target instanceof EEnumLiteral) {

+                        targetString = '''const_«target.name»_«target.EEnum.name»'''

+                        additionalDefinition = '''DefinedElement.name(«targetString»,"«target.name» «target.EEnum.name»");  //LogicProblem.elements(problem,«targetString»);'''

+                } else if(target instanceof Integer) {

+                        targetString = '''const_«target»_Integer'''

+                        additionalDefinition = '''PrimitiveElement.valueSet(«targetString»,true); IntegerElement.value(«targetString»,«target»);'''

+                } else if(target instanceof Boolean) {

+                        targetString = '''const_«target»_Boolean'''

+                        additionalDefinition = '''PrimitiveElement.valueSet(«targetString»,true); BooleanElement.value(«targetString»,«target»);'''

+                } else if(target instanceof String) {

+                        targetString = '''const_«target»_String'''

+                        additionalDefinition = '''PrimitiveElement.valueSet(«targetString»,true); StringElement.value(«targetString»,"«target»");'''

+                } else if(target instanceof Double) {

+                        targetString = '''const_«target»_Real'''

+                        additionalDefinition = '''PrimitiveElement.valueSet(«targetString»,true); RealElement.value(«targetString»,«target»);'''

+                } else if(target instanceof Float) {

+                        targetString = '''const_«target»_Real'''

+                        additionalDefinition = '''PrimitiveElement.valueSet(«targetString»,true); RealElement.value(«targetString»,«target»);'''

+                } else {

+                        throw new UnsupportedOperationException('''Unknown constant type: «target.class»''')

+                }

+                

+                val source = c.variablesTuple

+                var String sourceName

+                if(source.size == 1)

+                        sourceName = (source.get(0) as PVariable).canonizeName

+                else throw new UnsupportedOperationException("unknown source")

+                return '''«sourceName» == «targetString»;«additionalDefinition»''';

+        }

+        

+        protected def valueVariable(PVariable v) {

+                "value_"+v.canonizeName

+        }

+        protected def valueSetted(PVariable v) {

+                "setted_"+v.canonizeName

+        }

+        def hasValue(PVariable v, String target, Modality m, List<VariableMapping> variableMapping) {

+                val typeReference = variableMapping.filter[it.sourcePVariable === v].head.targetLogicVariable.range as PrimitiveTypeReference

+                if(m.isMay) {

+                        '''PrimitiveElement.valueSet(«v.canonizeName»,«v.valueSetted»); «hasValueExpressionByRef(typeReference,v,v.valueVariable)»

+«««                  check(!«v.valueSetted»||«v.valueVariable»==«target»));

+'''

+                } else { // Must or current

+                        '''PrimitiveElement.valueSet(«v.canonizeName»,true);«hasValueExpressionByRef(typeReference,v,target)»'''

+                }

+        }

+        

+        private def hasValueExpression(List<VariableMapping> variableMapping, PVariable v, String target) {

+                val mapping = variableMapping.filter[

+                        val v2 = (it.sourcePVariable as PVariable)

+                        v2 === v

+                ].head

+                val range = mapping.targetLogicVariable.range

+                hasValueExpressionByRef(

+                        range,

+                        v,

+                        target

+                )

+        }

+        private def dispatch hasValueExpressionByRef(BoolTypeReference typeReference, PVariable v, String target)       '''BooleanElement.value(«v.canonizeName»,«target»);'''

+        private def dispatch hasValueExpressionByRef(IntTypeReference typeReference, PVariable v, String target)                '''IntegerElement.value(«v.canonizeName»,«target»);'''

+        private def dispatch hasValueExpressionByRef(RealTypeReference typeReference, PVariable v, String target)       '''RealElement.value(«v.canonizeName»,«target»);'''

+        private def dispatch hasValueExpressionByRef(StringTypeReference typeReference, PVariable v, String target)     '''StringElement.value(«v.canonizeName»,«target»);'''

+        private def dispatch hasValueExpressionByRef(TypeReference typeReference, PVariable v, String target) {

+                throw new UnsupportedOperationException('''Unsupported primitive type reference: «typeReference.class»''')

+        }

+        

+        dispatch def transformConstraint(ExpressionEvaluation e, Modality modality, List<VariableMapping> variableMapping) {

+                if(e.outputVariable!==null) {

+                        throw new UnsupportedOperationException('''Only check expressions are supported "«e.class.name»"!''')

+                } else {

+                        val expression = expressionExtractor.extractExpression(e.evaluator)

+                        val Map<PVariable, PrimitiveTypeReference> variable2Type = e.affectedVariables.toInvertedMap[v|variableMapping.filter[it.sourcePVariable === v].head.targetLogicVariable.range as PrimitiveTypeReference]

+                        if(modality.isMay) {

+                                return '''

+                                        «FOR variable: e.affectedVariables»

+                                                PrimitiveElement.valueSet(«variable.canonizeName»,«variable.valueSetted»); «hasValueExpression(variableMapping,variable,variable.valueVariable)»

+                                        «ENDFOR»

+«««                                  check(

+«««                                          «FOR variable: e.affectedVariables SEPARATOR " || "»!«variable.valueSetted»«ENDFOR»

+«««                                          «IF variable2Type.values.filter(RealTypeReference).empty»

+«««                                          ||

+«««                                          («expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable],variable2Type)»)

+«««                                          «ENDIF»

+«««                                  );

+                                '''

+                        } else { // Must or Current

+                                return '''

+                                        «FOR variable: e.affectedVariables»

+                                                PrimitiveElement.valueSet(«variable.canonizeName»,true); «hasValueExpression(variableMapping,variable,variable.valueVariable)»

+                                        «ENDFOR»

+«««                                  «IF variable2Type.values.filter(RealTypeReference).empty»

+«««                                          check(«expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable],variable2Type)»);

+«««                                  «ENDIF»

+                                '''

+                        }

+                }

+        }

+

+        dispatch def transformConstraint(PConstraint c, Modality modality, List<VariableMapping> variableMapping) {

+                throw new UnsupportedOperationException('''Unknown constraint type: "«c.class.name»"!''')

+        }

+        

+        dispatch def transformConstraintUnset(ExpressionEvaluation e, List<VariableMapping> variableMapping) {

+                return '''

+                        «FOR variable: e.affectedVariables»

+                                PrimitiveElement.valueSet(«variable.canonizeName»,«variable.valueSetted»); «hasValueExpression(variableMapping,variable,variable.valueVariable)»

+                        «ENDFOR»

+«««                  check(«FOR variable: e.affectedVariables SEPARATOR " || "»!«variable.valueSetted»«ENDFOR»);

+                '''

+        }

+        

+        dispatch def transformConstraintUnset(PConstraint c, List<VariableMapping> variableMapping) {

+                throw new UnsupportedOperationException('''Unknown constraint type: "«c.class.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/PExpressionGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PExpressionGenerator.xtend
new file mode 100644
index 00000000..62ff92b2
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PExpressionGenerator.xtend
@@ -0,0 +1,116 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

+

+import java.util.Map

+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable

+import org.eclipse.xtext.xbase.XBinaryOperation

+import org.eclipse.xtext.xbase.XExpression

+import org.eclipse.xtext.xbase.XFeatureCall

+import org.eclipse.xtext.xbase.XMemberFeatureCall

+import org.eclipse.xtext.xbase.XNumberLiteral

+import org.eclipse.xtext.xbase.XUnaryOperation

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.PrimitiveTypeReference

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealTypeReference

+

+class PExpressionGenerator {

+        static val N_Base = "org.eclipse.xtext.xbase.lib."

+        

+        static val N_PLUS1 = "operator_plus"

+        static val N_MINUS1 = "operator_minus"

+        

+        static val N_MINUS2 = "operator_minus"

+        static val N_PLUS2 = "operator_plus"

+        static val N_POWER = "operator_power"

+        static val N_MULTIPLY = "operator_multiply"

+        static val N_DIVIDE = "operator_divide"

+        static val N_MODULO = "operator_modulo"

+        static val N_LESSTHAN = "operator_lessThan"

+        static val N_LESSEQUALSTHAN = "operator_lessEqualsThan"

+        static val N_GREATERTHAN = "operator_greaterThan"

+        static val N_GREATEREQUALTHAN = "operator_greaterEqualsThan"

+        static val N_EQUALS = "operator_equals"

+        static val N_NOTEQUALS = "operator_notEquals"

+        static val N_EQUALS3 = "operator_tripleEquals"

+        static val N_NOTEQUALS3 = "operator_tripleNotEquals"

+        

+        protected def isN(String name, String s) {

+                val res = name.startsWith(N_Base) && name.endsWith(s)

+                //println('''[«res»] «name» ?= «N_Base»*«s»''')

+                return res

+        }

+        

+        static val N_POWER2 = "java.lang.Math.pow"

+        

+        def dispatch CharSequence translateExpression(XBinaryOperation e, Map<PVariable,String> valueName, Map<PVariable, PrimitiveTypeReference> variable2Type) {

+                val left = e.leftOperand.translateExpression(valueName,variable2Type)

+                val right = e.rightOperand.translateExpression(valueName,variable2Type)

+                val feature = e.feature.qualifiedName

+                     if(feature.isN(N_MINUS2)) { return '''(«left»-«right»)'''}

+                else if(feature.isN(N_PLUS2)) { return '''(«left»+«right»)''' }

+                else if(feature.isN(N_POWER)) { return '''(«left»^«right»)'''  }

+                else if(feature.isN(N_MULTIPLY)) { return '''(«left»*«right»)''' }

+                else if(feature.isN(N_DIVIDE)) { return '''(«left»/«right»)''' }

+                else if(feature.isN(N_MODULO)) { return '''(«left»%«right»)''' }

+                else if(feature.isN(N_LESSTHAN)) { return '''(«left»<«right»)''' }

+                else if(feature.isN(N_LESSEQUALSTHAN)) { return '''(«left»<=«right»)''' }

+                else if(feature.isN(N_GREATERTHAN)) { return '''(«left»>«right»)''' }

+                else if(feature.isN(N_GREATEREQUALTHAN)) { return '''(«left»>=«right»)''' }

+                else if(feature.isN(N_EQUALS)) { return '''(«left»==«right»)''' }

+                else if(feature.isN(N_NOTEQUALS)) { return '''(«left»!=«right»)''' }

+                else if(feature.isN(N_EQUALS3)) { return '''(«left»===«right»)''' }

+                else if(feature.isN(N_NOTEQUALS3)) { return '''(«left»!==«right»)''' }

+                else {

+                        println("-> " + e.feature+","+e.class)

+                        println("-> " + e.leftOperand)

+                        println("-> " + e.rightOperand)

+                        println("-> " + e.feature.qualifiedName)

+                        throw new UnsupportedOperationException('''Unsupported binary operator feature: "«e.feature.class.simpleName»" - «e»''')

+                }

+        }

+        

+        def dispatch CharSequence translateExpression(XUnaryOperation e, Map<PVariable,String> valueName, Map<PVariable, PrimitiveTypeReference> variable2Type) {

+                val operand = e.operand.translateExpression(valueName,variable2Type)

+                val feature = e.feature.qualifiedName

+                if(feature.isN(N_MINUS1)) { return '''(-«operand»)'''}

+                else if(feature.isN(N_PLUS1)) { return '''(+«operand»)'''}

+                else{

+                        println("-> " + e.feature+","+e.class)

+                        println("-> " + e.operand)

+                        println("-> " + e.feature.qualifiedName)

+                        throw new UnsupportedOperationException('''Unsupported unary operator feature: "«e.feature.class.simpleName»" - «e»''')

+                }

+        }

+        

+        def dispatch CharSequence translateExpression(XMemberFeatureCall e, Map<PVariable,String> valueName, Map<PVariable, PrimitiveTypeReference> variable2Type) {

+                val transformedArguments = e.actualArguments.map[translateExpression(valueName,variable2Type)]

+                val feature = e.feature.qualifiedName

+                if(feature == N_POWER2) {

+                        return '''Math.pow(«transformedArguments.get(0)»,«transformedArguments.get(1)»)'''

+                }else {

+                        println(e.feature+","+e.class)

+                        println(e.actualArguments.join(", "))

+                        println(e.feature.qualifiedName)

+                        throw new UnsupportedOperationException('''Unsupported feature call: "«e.feature.qualifiedName»" - «e»''')

+                }

+        }

+        

+        def dispatch CharSequence translateExpression(XFeatureCall e, Map<PVariable,String> valueName, Map<PVariable, PrimitiveTypeReference> variable2Type) {

+                val featureName = e.feature.qualifiedName

+                val type = variable2Type.entrySet.filter[it.key.name===featureName].head.value

+                val entryWithName = valueName.entrySet.filter[it.key.name == featureName].head

+                if(entryWithName !== null) {

+                        if(type instanceof RealTypeReference) {

+                                return '''(«entryWithName.value».doubleValue)'''

+                        } else {

+                                return entryWithName.value

+                        }

+                } else {

+                        throw new IllegalArgumentException('''Feature call reference to unavailable variable "«featureName»"''')

+                }

+        }

+        

+        def dispatch CharSequence translateExpression(XNumberLiteral l, Map<PVariable,String> valueName, Map<PVariable, PrimitiveTypeReference> variable2Type) '''«l.value»'''

+        

+        def dispatch CharSequence translateExpression(XExpression expression, Map<PVariable,String> valueName, Map<PVariable, PrimitiveTypeReference> variable2Type) {

+                throw new UnsupportedOperationException('''Unsupported expression in check or eval: «expression.class.name», «expression»"''')

+        }

+}
\ 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 d4c76bb4..edf92343 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,31 +16,55 @@ 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

 import org.eclipse.emf.ecore.EReference

+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.Accessors

+import org.eclipse.xtend.lib.annotations.Data

+import org.eclipse.xtend2.lib.StringConcatenationClient

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

 

+@Data class PatternGeneratorResult {

+        CharSequence patternText

+        HashMap<PConstraint,String> constraint2MustPreconditionName

+        HashMap<PConstraint,String> constraint2CurrentPreconditionName

+}

+

+interface UnitPropagationPatternGenerator {

+        def Map<Relation, String> getMustPatterns()

+        

+        def Map<Relation, String> getMustNotPatterns()

+        

+        def StringConcatenationClient getAdditionalPatterns(PatternGenerator generator, Map<String, PQuery> fqn2PQuery)

+}

+

 class PatternGenerator {

-        @Accessors(PUBLIC_GETTER) val TypeIndexer typeIndexer //= new TypeIndexer(this)

-        @Accessors(PUBLIC_GETTER) val RelationDeclarationIndexer relationDeclarationIndexer = new RelationDeclarationIndexer(this)

-        @Accessors(PUBLIC_GETTER) val RelationDefinitionIndexer relationDefinitionIndexer = new RelationDefinitionIndexer(this)

+        @Accessors(PUBLIC_GETTER) val TypeIndexer typeIndexer // = new TypeIndexer(this)

+        @Accessors(PUBLIC_GETTER) val RelationDeclarationIndexer relationDeclarationIndexer = new RelationDeclarationIndexer(

+                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) {

+        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 {

@@ -49,113 +72,105 @@ 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(

-                RelationDeclaration referred,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality,

-                Map<String,PQuery> fqn2PQuery)

-        {

-                return this.relationDeclarationIndexer.referRelation(referred,sourceVariable,targetVariable,modality)

+

+        dispatch def CharSequence referRelation(RelationDeclaration referred, String sourceVariable, String targetVariable,

+                Modality modality, Map<String, PQuery> fqn2PQuery) {

+                return this.relationDeclarationIndexer.referRelation(referred, sourceVariable, targetVariable, modality)

         }

-        public dispatch def referRelation(

-                RelationDefinition referred,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality,

-                Map<String,PQuery> fqn2PQuery)

-        {

-                val pattern = referred.annotations.filter(TransfomedViatraQuery).head.patternFullyQualifiedName.lookup(fqn2PQuery)

-                return this.relationDefinitionIndexer.referPattern(pattern,#[sourceVariable,targetVariable],modality,true,false)

+

+        dispatch def CharSequence referRelation(RelationDefinition referred, String sourceVariable, String targetVariable,

+                Modality modality, Map<String, PQuery> fqn2PQuery) {

+                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,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality)

-        {

-                '''find «modality.name.toLowerCase»InRelation«canonizeName('''«reference.name» reference «reference.EContainingClass.name»''')

-                »(problem,interpretation,«sourceVariable»,«targetVariable»);'''

+

+        def referRelationByName(EReference reference, String sourceVariable, 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,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality)

-        {

-                '''find «modality.name.toLowerCase»InRelation«canonizeName('''«attribute.name» attribute «attribute.EContainingClass.name»''')

-                »(problem,interpretation,«sourceVariable»,«targetVariable»);'''

+

+        def CharSequence referAttributeByName(EAttribute attribute, String sourceVariable, String 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) {

-                problem.assertions.map[annotations].flatten.filter(LowerMultiplicityAssertion).filter[!it.relation.isDerived]

-        }

-        public def wfQueries(LogicProblem problem) {

-                problem.assertions.map[it.annotations]

-                        .flatten

-                        .filter(TransformedViatraWellformednessConstraint)

-                        .map[it.query]

+

+        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[

-                        inverseRelations.put(it.inverseA,it.inverseB)

-                        inverseRelations.put(it.inverseB,it.inverseA)

+                p.annotations.filter(InverseRelationAssertion).forEach [

+                        inverseRelations.put(it.inverseA, it.inverseB)

+                        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 transformBaseProperties(

+

+        def transformBaseProperties(

                 LogicProblem problem,

                 PartialInterpretation emptySolution,

-                Map<String,PQuery> fqn2PQuery,

-                TypeAnalysisResult typeAnalysisResult

+                Map<String, PQuery> fqn2PQuery,

+                TypeAnalysisResult typeAnalysisResult,

+                RelationConstraints constraints,

+                Collection<LinearTypeConstraintHint> hints,

+                Collection<UnitPropagationPatternGenerator> unitPropagationPatternGenerators

         ) {

-                

-                return '''

+                val first = 

+                 '''

                         import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage"

                         import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem"

                         import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language"

@@ -170,6 +185,7 @@ class PatternGenerator {
                         /////////////////////////

                         // 0.1 Existence

                         /////////////////////////

+                        /** [[exist(element)]]=1 */

                         private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {

                                 find interpretation(problem,interpretation);

                                 LogicProblem.elements(problem,element);

@@ -178,6 +194,7 @@ class PatternGenerator {
                                 PartialInterpretation.newElements(interpretation,element);

                         }

                         

+                        /** [[exist(element)]]>=1/2 */

                         private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {

                             find mustExist(problem,interpretation,element);

                         } or {

@@ -188,7 +205,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);

@@ -198,64 +215,115 @@ class PatternGenerator {
                         ////////////////////////

                         // 0.2 Equivalence

                         ////////////////////////

-                        pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) {

+                        pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement)

+                        // For non-primitive type. Boolean types always must equivalent or cannot equivalent

+                        {

                                 find mayExist(problem,interpretation,a);

                                 find mayExist(problem,interpretation,b);

                                 a == b;

+«««                  } or {

+«««                          find mayExist(problem,interpretation,a);

+«««                          find mayExist(problem,interpretation,b);

+«««                          IntegerElement(a);

+«««                          IntegerElement(b);

+«««                          PrimitiveElement.valueSet(a,false);

+«««                  } or {

+«««                          find mayExist(problem,interpretation,a);

+«««                          find mayExist(problem,interpretation,b);

+«««                          IntegerElement(a);

+«««                          IntegerElement(b);

+«««                          PrimitiveElement.valueSet(b,false);

+«««                  } or {

+«««                          find mayExist(problem,interpretation,a);

+«««                          find mayExist(problem,interpretation,b);

+«««                          RealElement(a);

+«««                          RealElement(b);

+«««                          PrimitiveElement.valueSet(a,false);

+«««                  } or {

+«««                          find mayExist(problem,interpretation,a);

+«««                          find mayExist(problem,interpretation,b);

+«««                          RealElement(a);

+«««                          RealElement(b);

+«««                          PrimitiveElement.valueSet(b,false);

+«««                  } or {

+«««                          find mayExist(problem,interpretation,a);

+«««                          find mayExist(problem,interpretation,b);

+«««                          StringElement(a);

+«««                          StringElement(b);

+«««                          PrimitiveElement.valueSet(a,false);

+«««                  } or {

+«««                          find mayExist(problem,interpretation,a);

+«««                          find mayExist(problem,interpretation,b);

+«««                          StringElement(a);

+«««                          StringElement(b);

+«««                          PrimitiveElement.valueSet(b,false);

                         }

+                        

                         pattern mustEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) {

+                        // For non-primitive and Boolean primitive type

                                 find mustExist(problem,interpretation,a);

                                 find mustExist(problem,interpretation,b);

                                 a == b;

+«««                  } or {

+«««                          find mustExist(problem,interpretation,a);

+«««                          find mustExist(problem,interpretation,b);

+«««                          PrimitiveElement.valueSet(a,true);

+«««                          PrimitiveElement.valueSet(b,true);

+«««                          IntegerElement.value(a,value);

+«««                          IntegerElement.value(b,value);

+«««                  } or {

+«««                          find mustExist(problem,interpretation,a);

+«««                          find mustExist(problem,interpretation,b);

+«««                          PrimitiveElement.valueSet(a,true);

+«««                          PrimitiveElement.valueSet(b,true);

+«««                          RealElement.value(a,value);

+«««                          RealElement.value(b,value);

+«««                  } or {

+«««                          find mustExist(problem,interpretation,a);

+«««                          find mustExist(problem,interpretation,b);

+«««                          PrimitiveElement.valueSet(a,true);

+«««                          PrimitiveElement.valueSet(b,true);

+«««                          StringElement.value(a,value);

+«««                          StringElement.value(b,value);

                         }

                         

-                        ////////////////////////

-                        // 0.3 Required Patterns by TypeIndexer

-                        ////////////////////////

-                        «typeIndexer.requiredQueries»

-                        

                         //////////

                         // 1. Problem-Specific Base Indexers

                         //////////

                         // 1.1 Type Indexers

                         //////////

-                        // 1.1.1 primitive Type Indexers

+                        // 1.1.1 Required Patterns by TypeIndexer

                         //////////

-«««                  pattern instanceofBoolean(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {

-«««                          find interpretation(problem,interpretation);

-«««                          PartialInterpretation.booleanelements(interpretation,element);

-«««                  }

-«««                  pattern instanceofInteger(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {

-«««                          find interpretation(problem,interpretation);

-«««                          PartialInterpretation.integerelements(interpretation,element);

-«««                  } or {

-«««                          find interpretation(problem,interpretation);

-«««                          PartialInterpretation.newIntegers(interpetation,element);

-«««                  }

-«««                  pattern instanceofReal(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {

-«««                          find interpretation(problem,interpretation);

-«««                          PartialInterpretation.realelements(interpretation,element);

-«««                  } or {

-«««                          find interpretation(problem,interpretation);

-«««                          PartialInterpretation.newReals(interpetation,element);

-«««                  }

-«««                  pattern instanceofString(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {

-«««                          find interpretation(problem,interpretation);

-«««                          PartialInterpretation.stringelements(interpretation,element);

-«««                  } or {

-«««                          find interpretation(problem,interpretation);

-«««                          PartialInterpretation.newStrings(interpetation,element);

-«««                  }

+

+                        «typeIndexer.requiredQueries»

                         

                         //////////

-                        // 1.1.2 domain-specific Type Indexers

+                        // 1.1.2 primitive Type Indexers

+                        //////////

+                        // Currently unused. Refer primitive types as:

+                        // > PrimitiveElement(element)

+                        // specific types are referred as:

+                        // > BooleanElement(variableName)

+                        // > IntegerElement(variableName)

+                        // > RealElement(variableName)

+                        // > StringElement(variableName)

+                        // And their value as

+                        // > BooleanElement.value(variableName,value)

+                        // > IntegerElement.value(variableName,value)

+                        // > RealElement.value(variableName,value)

+                        // > StringElement.value(variableName,value)

+                        // Whether a value is set is defined by:

+                        // > PrimitiveElement.valueSet(variableName,isFilled);

+                        

+                        //////////

+                        // 1.1.3 domain-specific Type Indexers

                         //////////

                         «typeIndexer.generateInstanceOfQueries(problem,emptySolution,typeAnalysisResult)»

                         

                         //////////

                         // 1.2 Relation Declaration Indexers

                         //////////

-                        «relationDeclarationIndexer.generateRelationIndexers(problem,problem.relations.filter(RelationDeclaration),fqn2PQuery)»

+                        «relationDeclarationIndexer.generateRelationIndexers(problem,problem.relations.filter(RelationDeclaration),unitPropagationPatternGenerators,fqn2PQuery)»

                         

                         //////////

                         // 1.3 Relation Definition Indexers

@@ -279,7 +347,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

@@ -301,7 +369,24 @@ class PatternGenerator {
                         //////////

                         // 4.3 Relation refinement

                         //////////

-                        «relationRefinementGenerator.generateRefineReference(problem)»

+                        «relationRefinementGenerator.generateRefineReference(problem, unitPropagationPatternGenerators)»

+                        

+                        //////////

+                        // 5 Hints

+                        //////////

+                        «FOR hint : hints»

+                                «hint.getAdditionalPatterns(this, fqn2PQuery)»

+                        «ENDFOR»

+                        «FOR generator : unitPropagationPatternGenerators»

+                                «generator.getAdditionalPatterns(this, fqn2PQuery)»

+                        «ENDFOR»

+                        

+                        //////////

+                        // 6 Unit Propagations

+                        //////////

                         '''

+                val up = unitPropagationPreconditionGenerator.generateUnitPropagationRules(problem,problem.relations.filter(RelationDefinition),fqn2PQuery)

+                val second = up.definitions

+                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 0e13a5e1..2e786286 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
@@ -1,97 +1,171 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

 

+import com.google.common.collect.ImmutableSet

 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

 

 @Data class GeneratedPatterns {

-        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>>> unfinishedMulticiplicityQueries

-        public Map<ObjectCreationPrecondition,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineObjectQueries

-        public Map<? extends Type,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineTypeQueries

-        public Map<Pair<RelationDeclaration, Relation>,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refinerelationQueries

+        public Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidWFQueries

+        public Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWFQueries

+        public Map<RelationMultiplicityConstraint, UnifinishedMultiplicityQueries> multiplicityConstraintQueries

+        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<Pair<RelationDeclaration, Relation>, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineRelationQueries

+        public Map<Pair<RelationDeclaration, Relation>, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> mustRelationPropagationQueries

+        public Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> mustUnitPropagationPreconditionPatterns

+        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>> existingMultiplicityQuery

+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> existingInverseMultiplicityQuery

+

+        def Set<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> getAllQueries() {

+                val builder = ImmutableSet.builder

+                if (existingMultiplicityQuery !== null) {

+                        builder.add(existingMultiplicityQuery)

+                }

+                if (existingInverseMultiplicityQuery !== null) {

+                        builder.add(existingInverseMultiplicityQuery)

+                }

+                builder.build

+        }

+}

+

 class PatternProvider {

-        

         val TypeAnalysis typeAnalysis = new TypeAnalysis

-        

-        public def generateQueries(

-                LogicProblem problem,

-                PartialInterpretation emptySolution,

-                ModelGenerationStatistics statistics,

-                Set<PQuery> existingQueries,

-                ReasonerWorkspace workspace,

-                TypeInferenceMethod typeInferenceMethod,

-                boolean writeToFile)

-        {

+

+        def generateQueries(LogicProblem problem, PartialInterpretation emptySolution, ModelGenerationStatistics statistics,

+                Set<PQuery> existingQueries, ReasonerWorkspace workspace, TypeInferenceMethod typeInferenceMethod,

+                ScopePropagatorStrategy scopePropagatorStrategy, RelationConstraints relationConstraints,

+                Collection<LinearTypeConstraintHint> hints,

+                Collection<UnitPropagationPatternGenerator> unitPropagationPatternGenerators, boolean writeToFile) {

                 val fqn2Query = existingQueries.toMap[it.fullyQualifiedName]

-                val PatternGenerator patternGenerator = new PatternGenerator(typeInferenceMethod)

-                val typeAnalysisResult = if(patternGenerator.requiresTypeAnalysis) {

-                        val startTime = System.nanoTime

-                        val result = typeAnalysis.performTypeAnalysis(problem,emptySolution)

-                        val typeAnalysisTime = System.nanoTime - startTime

-                        statistics.PreliminaryTypeAnalisisTime = typeAnalysisTime

-                        result

-                } else {

-                        null

-                }

-                val baseIndexerFile = patternGenerator.transformBaseProperties(problem,emptySolution,fqn2Query,typeAnalysisResult)

-                if(writeToFile) {

-                        workspace.writeText('''generated3valued.vql_deactivated''',baseIndexerFile)

+                val PatternGenerator patternGenerator = new PatternGenerator(typeInferenceMethod, scopePropagatorStrategy)

+                val typeAnalysisResult = if (patternGenerator.requiresTypeAnalysis) {

+                                val startTime = System.nanoTime

+                                val result = typeAnalysis.performTypeAnalysis(problem, emptySolution)

+                                val typeAnalysisTime = System.nanoTime - startTime

+                                statistics.preliminaryTypeAnalisisTime = typeAnalysisTime

+                                result

+                        } else {

+                                null

+                        }

+                val patternGeneratorResult = patternGenerator.transformBaseProperties(problem, emptySolution, fqn2Query,

+                        typeAnalysisResult, relationConstraints, hints, unitPropagationPatternGenerators)

+                if (writeToFile) {

+                        workspace.writeText('''generated3valued.vql_deactivated''', patternGeneratorResult.patternText)

                 }

                 val ParseUtil parseUtil = new ParseUtil

-                val generatedQueries = parseUtil.parse(baseIndexerFile)

-                val runtimeQueries = calclulateRuntimeQueries(patternGenerator,problem,emptySolution,typeAnalysisResult,generatedQueries);

+                val generatedQueries = parseUtil.parse(patternGeneratorResult.patternText)

+                val runtimeQueries = calclulateRuntimeQueries(patternGenerator, problem, emptySolution, typeAnalysisResult,

+                        patternGeneratorResult.constraint2MustPreconditionName,

+                        patternGeneratorResult.constraint2CurrentPreconditionName, relationConstraints,

+                        unitPropagationPatternGenerators, generatedQueries)

                 return runtimeQueries

         }

-        

+

         private def GeneratedPatterns calclulateRuntimeQueries(

                 PatternGenerator patternGenerator,

                 LogicProblem problem,

                 PartialInterpretation emptySolution,

                 TypeAnalysisResult typeAnalysisResult,

-                 Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> queries

+                HashMap<PConstraint, String> mustUnitPropagationTrace,

+                HashMap<PConstraint, String> currentUnitPropagationTrace,

+                RelationConstraints relationConstraints,

+                Collection<UnitPropagationPatternGenerator> unitPropagationPatternGenerators,

+                Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> queries

         ) {

-                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>>>

-                        unfinishedWFQueries = patternGenerator.unfinishedIndexer.getUnfinishedWFQueryNames(problem).mapValues[it.lookup(queries)]

-                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>>>

-                        refineTypeQueries = patternGenerator.typeRefinementGenerator.getRefineTypeQueryNames(problem,emptySolution,typeAnalysisResult).mapValues[it.lookup(queries)]

-                val Map<Pair<RelationDeclaration, Relation>,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>

-                        refineRelationQueries = patternGenerator.relationRefinementGenerator.getRefineRelationQueries(problem).mapValues[it.lookup(queries)]

+                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>>> unfinishedWFQueries = patternGenerator.

+                        unfinishedIndexer.getUnfinishedWFQueryNames(problem).mapValues[it.lookup(queries)]

+

+                val unfinishedMultiplicities = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(

+                        relationConstraints.multiplicityConstraints)

+                val multiplicityConstraintQueries = unfinishedMultiplicities.mapValues [

+                        new UnifinishedMultiplicityQueries(existingMultiplicityQueryName?.lookup(queries),

+                                existingInverseMultiplicityQueryName?.lookup(queries))

+                ]

+                val hasElementInContainmentQuery = patternGenerator.typeRefinementGenerator.hasElementInContainmentName.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>>> refineTypeQueries = patternGenerator.

+                        typeRefinementGenerator.getRefineTypeQueryNames(problem, emptySolution, typeAnalysisResult).mapValues [

+                                it.lookup(queries)

+                        ]

+                val Map<Pair<RelationDeclaration, Relation>, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineRelationQueries = patternGenerator.

+                        relationRefinementGenerator.getRefineRelationQueries(problem).mapValues[it.lookup(queries)]

+                val Map<Pair<RelationDeclaration, Relation>, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> mustRelationPropagationQueries = patternGenerator.

+                        relationRefinementGenerator.getMustPropagationQueries(problem, unitPropagationPatternGenerators).mapValues[it.lookup(queries)]

+                val Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> 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,

-                        unfinishedMultiplicityQueries,

+                        multiplicityConstraintQueries,

+                        hasElementInContainmentQuery,

                         refineObjectsQueries,

                         refineTypeQueries,

                         refineRelationQueries,

+                        mustRelationPropagationQueries,

+                        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/RelationDeclarationIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
index f384cd50..23ba3cad 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
@@ -1,10 +1,13 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

 

+import com.google.common.collect.ImmutableMap

+import com.google.common.collect.ImmutableSet

 import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.UpperMultiplicityAssertion

 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.logicproblem.LogicProblem

 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality

+import java.util.Collection

 import java.util.HashMap

 import java.util.List

 import java.util.Map

@@ -14,41 +17,40 @@ import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
 

 class RelationDeclarationIndexer {

         val PatternGenerator base;

-        

+

         new(PatternGenerator base) {

                 this.base = base

         }

-        

-        public def generateRelationIndexers(LogicProblem problem, Iterable<RelationDeclaration> relations, Map<String,PQuery> fqn2PQuery) {

+

+        def generateRelationIndexers(LogicProblem problem, Iterable<RelationDeclaration> relations,

+                Iterable<UnitPropagationPatternGenerator> unitPropagationPatternGenerators, Map<String, PQuery> fqn2PQuery) {

                 val upperMultiplicities = new HashMap

-                problem.annotations.filter(UpperMultiplicityAssertion).forEach[

-                        upperMultiplicities.put(it.relation,it.upper)

+                problem.annotations.filter(UpperMultiplicityAssertion).forEach [

+                        upperMultiplicities.put(it.relation, it.upper)

                 ]

-                

+                val mustNotRelations = ImmutableMap.copyOf(unitPropagationPatternGenerators.flatMap[mustNotPatterns.entrySet].

+                        groupBy[key].mapValues[ImmutableSet.copyOf(map[value])])

+

                 return '''

-                «FOR relation : relations»

-                        «IF base.isDerived(relation)»

-                                «generateDerivedMustRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»

-                                «generateDerivedMayRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»

-                        «ELSE»

-                                «generateMustRelation(problem,relation)»

-                                «generateMayRelation(problem,relation,upperMultiplicities,base.getContainments(problem),base.getInverseRelations(problem),fqn2PQuery)»

-                        «ENDIF»

-                «ENDFOR»

+                        «FOR relation : relations»

+                                «IF base.isDerived(relation)»

+                                        «generateDerivedMustRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»

+                                        «generateDerivedMayRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»

+                                «ELSE»

+                                        «generateMustRelation(problem, relation)»

+                                        «generateMayRelation(problem, relation, upperMultiplicities, base.getContainments(problem), base.getInverseRelations(problem), mustNotRelations.get(relation) ?: emptySet, fqn2PQuery)»

+                                «ENDIF»

+                        «ENDFOR»

                 '''

         }

-        

+

         def private patternName(RelationDeclaration r, Modality modality) {

                 '''«modality.name.toLowerCase»InRelation«base.canonizeName(r.name)»'''

         }

-        

-        public def referRelation(

-                RelationDeclaration referred,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality)

-        '''find «referred.patternName(modality)»(problem,interpretation,«sourceVariable»,«targetVariable»);'''

-        

+

+        def referRelation(RelationDeclaration referred, String sourceVariable, String targetVariable,

+                Modality modality) '''find «referred.patternName(modality)»(problem,interpretation,«sourceVariable»,«targetVariable»);'''

+

         def generateMustRelation(LogicProblem problem, RelationDeclaration relation) '''

                 /**

                  * Matcher for detecting tuples t where []«relation.name»(source,target)

@@ -65,59 +67,64 @@ class RelationDeclarationIndexer {
                         BinaryElementRelationLink.param2(link,target);

                 }

         '''

+

         def generateMayRelation(LogicProblem problem, RelationDeclaration relation,

-                Map<Relation, Integer> upperMultiplicities,

-                List<Relation> containments,

-                HashMap<Relation, Relation> inverseRelations,

-                Map<String,PQuery> fqn2PQuery)

-        {

+                Map<Relation, Integer> upperMultiplicities, List<Relation> containments,

+                HashMap<Relation, Relation> inverseRelations, Collection<String> mustNotRelations,

+                Map<String, PQuery> fqn2PQuery) {

                 return '''

-                /**

-                 * Matcher for detecting tuples t where <>«relation.name»(source,target)

-                 */

-                private pattern «relation.patternName(Modality.MAY)»(

-                        problem:LogicProblem, interpretation:PartialInterpretation,

-                        source: DefinedElement, target:DefinedElement)

-                {

-                        find interpretation(problem,interpretation);

-                        // The two endpoint of the link have to exist

-                        find mayExist(problem, interpretation, source);

-                        find mayExist(problem, interpretation, target);

-                        // Type consistency

-                        «base.typeIndexer.referInstanceOfByReference(relation.parameters.get(0),Modality.MAY,"source")»

-                        «base.typeIndexer.referInstanceOfByReference(relation.parameters.get(1),Modality.MAY,"target")»

-                        «IF upperMultiplicities.containsKey(relation)»

-                                // There are "numberOfExistingReferences" currently existing instances of the reference from the source,

-                                // the upper bound of the multiplicity should be considered.

-                                numberOfExistingReferences == count «referRelation(relation,"source","_",Modality.MUST)»

-                                check(numberOfExistingReferences < «upperMultiplicities.get(relation)»);

-                        «ENDIF»

-                        «IF inverseRelations.containsKey(relation) && upperMultiplicities.containsKey(inverseRelations.get(relation))»

-                                // There are "numberOfExistingReferences" currently existing instances of the reference to the target,

-                                // the upper bound of the opposite reference multiplicity should be considered.

-                                numberOfExistingOppositeReferences == count «base.referRelation(inverseRelations.get(relation),"target","_",Modality.MUST,fqn2PQuery)»

-                                check(numberOfExistingOppositeReferences < «upperMultiplicities.get(inverseRelations.get(relation))»);

-                        «ENDIF»

-                        «IF containments.contains(relation)»

-                                // The reference is containment, then a new reference cannot be create if:

-                                // 1. Multiple parents

-                                neg «base.containmentIndexer.referMustContaint("_","target")»

-                                // 2. Circle in the containment hierarchy

-                                neg «base.containmentIndexer.referTransitiveMustContains("target","source")»

-                        «ENDIF»

-                        «IF inverseRelations.containsKey(relation) && containments.contains(inverseRelations.get(relation))»

-                                // The eOpposite of the reference is containment, then a referene cannot be created if

-                                // 1. Multiple parents

-                                neg «base.containmentIndexer.referMustContaint("source","_")»

-                                // 2. Circle in the containment hierarchy

-                                neg «base.containmentIndexer.referTransitiveMustContains("source","target")»

-                        «ENDIF»

-                } or {

-                        «relation.referRelation("source","target",Modality.MUST)»

-                }

-        '''

+                        /**

+                         * Matcher for detecting tuples t where <>«relation.name»(source,target)

+                         */

+                        private pattern «relation.patternName(Modality.MAY)»(

+                                problem:LogicProblem, interpretation:PartialInterpretation,

+                                source: DefinedElement, target:DefinedElement)

+                        {

+                                find interpretation(problem,interpretation);

+                                // The two endpoint of the link have to exist

+                                find mayExist(problem, interpretation, source);

+                                find mayExist(problem, interpretation, target);

+                                // Type consistency

+                                «base.typeIndexer.referInstanceOfByReference(relation.parameters.get(0),Modality.MAY,"source")»

+                                «base.typeIndexer.referInstanceOfByReference(relation.parameters.get(1),Modality.MAY,"target")»

+                                «IF upperMultiplicities.containsKey(relation)»

+                                        // There are "numberOfExistingReferences" currently existing instances of the reference from the source,

+                                        // the upper bound of the multiplicity should be considered.

+                                        numberOfExistingReferences == count «referRelation(relation,"source","_",Modality.MUST)»

+                                        numberOfExistingReferences != «upperMultiplicities.get(relation)»;

+                                «ENDIF»

+                                «IF inverseRelations.containsKey(relation) && upperMultiplicities.containsKey(inverseRelations.get(relation))»

+                                        // There are "numberOfExistingReferences" currently existing instances of the reference to the target,

+                                        // the upper bound of the opposite reference multiplicity should be considered.

+                                        numberOfExistingOppositeReferences == count «base.referRelation(inverseRelations.get(relation),"target","_",Modality.MUST,fqn2PQuery)»

+                                        numberOfExistingOppositeReferences != «upperMultiplicities.get(inverseRelations.get(relation))»;

+                                «ENDIF»

+                                «IF containments.contains(relation)»

+                                        // The reference is containment, then a new reference cannot be create if:

+                                        // 1. Multiple parents

+                                        neg «base.containmentIndexer.referMustContaint("_","target")»

+                                        // 2. Circle in the containment hierarchy

+                                        neg «base.containmentIndexer.referTransitiveMustContains("target","source")»

+                                «ENDIF»

+                                «IF inverseRelations.containsKey(relation) && containments.contains(inverseRelations.get(relation))»

+                                        // The eOpposite of the reference is containment, then a referene cannot be created if

+                                        // 1. Multiple parents

+                                        neg «base.containmentIndexer.referMustContaint("source","_")»

+                                        // 2. Circle in the containment hierarchy

+                                        neg «base.containmentIndexer.referTransitiveMustContains("source","target")»

+                                «ENDIF»

+                                «IF !mustNotRelations.empty»

+                                        // ![] unit propagation relations

+                                        «FOR mustNotRelation : mustNotRelations»

+                                                neg find «mustNotRelation»(problem, interpretation, source, target);

+                                        «ENDFOR»

+                                «ENDIF»

+                        } or {

+                                «relation.referRelation("source","target",Modality.MUST)»

+                        }

+                '''

         }

-        

+

         def generateDerivedMustRelation(LogicProblem problem, RelationDeclaration relation, PQuery definition) '''

                 /**

                  * Matcher for detecting tuples t where []«relation.name»(source,target)

@@ -129,6 +136,7 @@ class RelationDeclarationIndexer {
                         «base.relationDefinitionIndexer.referPattern(definition,#["source","target"],Modality::MUST,true,false)»

                  }

         '''

+

         def generateDerivedMayRelation(LogicProblem problem, RelationDeclaration relation, PQuery definition) '''

                 /**

                  * Matcher for detecting tuples t where []«relation.name»(source,target)

@@ -140,4 +148,4 @@ class RelationDeclarationIndexer {
                         «base.relationDefinitionIndexer.referPattern(definition,#["source","target"],Modality::MAY,true,false)»

                  }

         '''

-}
\ 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/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 9723373f..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
@@ -5,38 +5,27 @@ 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.Modality

 import java.util.Map

-import org.eclipse.emf.ecore.EAttribute

-import org.eclipse.emf.ecore.EEnumLiteral

-import org.eclipse.emf.ecore.EReference

-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey

-import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey

-import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey

-import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint

 import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall

 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall

-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint

+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.basicdeferred.TypeFilterConstraint

 

 class RelationDefinitionIndexer {

-        val PatternGenerator base;

+        public val PatternGenerator base;

+        val PConstraintTransformer constraintTransformer;

         

         new(PatternGenerator base) {

                 this.base = base

+                this.constraintTransformer = new PConstraintTransformer(this);

         }

         

-        public def generateRelationDefinitions(

+        def generateRelationDefinitions(

                 LogicProblem problem,

                 Iterable<RelationDefinition> relations,

-                Map<String,PQuery> fqn2PQuery) {

+                Map<String,PQuery> fqn2PQuery)

+        {

                 val relation2PQuery = relations.toInvertedMap[

                         annotations.filter(TransfomedViatraQuery).head.patternFullyQualifiedName.lookup(fqn2PQuery)

                 ]

@@ -71,23 +60,24 @@ class RelationDefinitionIndexer {
                 ]

         }

         

-        private def relationDefinitionName(RelationDefinition relation, Modality modality)

+        def String relationDefinitionName(RelationDefinition relation, Modality modality)

                 '''«modality.name.toLowerCase»InRelation_«base.canonizeName(relation.name)»'''

         

-        private def canonizeName(PVariable v) {

+        def canonizeName(PVariable v) {

                 return '''«IF v.referringConstraints.size == 1»_«ENDIF»var_«v.name.replaceAll("\\W","")»'''

         }

         

         private def transformPattern(RelationDefinition relation, PQuery p, Modality modality) {

                 try {

+                val bodies = (relation.annotations.filter(TransfomedViatraQuery).head.optimizedDisjunction as PDisjunction).bodies

                 return '''

                         private pattern «relationDefinitionName(relation,modality)»(

                                 problem:LogicProblem, interpretation:PartialInterpretation,

                                 «FOR param : p.parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)

-                        «FOR body : p.disjunctBodies.bodies SEPARATOR "or"»{

+                        «FOR body : bodies SEPARATOR "or"»{

                                 find interpretation(problem,interpretation);

                                 «FOR constraint : body.constraints»

-                                        «constraint.transformConstraint(modality)»

+                                        «this.constraintTransformer.transformConstraint(constraint,modality,relation.annotations.filter(TransfomedViatraQuery).head.variableTrace)»

                                 «ENDFOR»

                         }«ENDFOR»

                 '''

@@ -104,158 +94,12 @@ class RelationDefinitionIndexer {
                 '''

         }

         

-        private def toMustMay(Modality modality) {

+        def toMustMay(Modality modality) {

                 if(modality == Modality::MAY) return Modality::MAY

                 else return Modality::MUST

         } 

         

-        def public referPattern(PQuery p, String[] variables, Modality modality, boolean positive, boolean transitive) '''

+        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(',')»);

         '''

-        

-        private dispatch def transformConstraint(TypeConstraint constraint, Modality modality) {

-                val touple = constraint.variablesTuple

-                if(touple.size == 1) {

-                        val inputKey = constraint.equivalentJudgement.inputKey

-                        if(inputKey instanceof EClassTransitiveInstancesKey) {

-                                return base.typeIndexer.referInstanceOf(inputKey.emfKey,modality.toMustMay,

-                                        constraint.getVariableInTuple(0).canonizeName)

-                        } else if(inputKey instanceof EDataTypeInSlotsKey){

-                                return '''// type constraint is enforced by construction'''

-                        }

-                        

-                } else if(touple.size == 2){

-                        val key = (constraint.equivalentJudgement.inputKey as EStructuralFeatureInstancesKey).emfKey

-                        if(key instanceof EReference) {

-                                return base.referRelationByName(

-                                        key,

-                                        constraint.getVariableInTuple(0).canonizeName,

-                                        constraint.getVariableInTuple(1).canonizeName,

-                                        modality.toMustMay)

-                        } else if (key instanceof EAttribute) {

-                                return base.referAttributeByName(key,

-                                        constraint.getVariableInTuple(0).canonizeName,

-                                        constraint.getVariableInTuple(1).canonizeName,

-                                        modality.toMustMay)

-                        } else throw new UnsupportedOperationException('''unknown key: «key.class»''')

-                } else {

-                        throw new UnsupportedOperationException('''Unsupported touple size: «touple.size»''')

-                }

-        }

-        private dispatch def transformConstraint(TypeFilterConstraint constraint, Modality modality) {

-                val touple = constraint.variablesTuple

-                if(touple.size == 1) {

-                        val inputKey = constraint.equivalentJudgement.inputKey

-                        if(inputKey instanceof EClassTransitiveInstancesKey) {

-                                return base.typeIndexer.referInstanceOf(inputKey.emfKey,modality.toMustMay,

-                                        (constraint.getVariablesTuple.get(0) as PVariable).canonizeName)

-                        } else if(inputKey instanceof EDataTypeInSlotsKey){

-                                return '''// type constraint is enforced by construction'''

-                        }

-                        

-                } else if(touple.size == 2){

-                        val key = (constraint.equivalentJudgement.inputKey as EStructuralFeatureInstancesKey).emfKey

-                        if(key instanceof EReference) {

-                                return base.referRelationByName(

-                                        key,

-                                        (constraint.getVariablesTuple.get(0) as PVariable).canonizeName,

-                                        (constraint.getVariablesTuple.get(1) as PVariable).canonizeName,

-                                        modality.toMustMay)

-                        } else if (key instanceof EAttribute) {

-                                return base.referAttributeByName(key,

-                                        (constraint.getVariablesTuple.get(0) as PVariable).canonizeName,

-                                        (constraint.getVariablesTuple.get(1) as PVariable).canonizeName,

-                                        modality.toMustMay)

-                        } else throw new UnsupportedOperationException('''unknown key: «key.class»''')

-                } else {

-                        throw new UnsupportedOperationException('''Unsupported touple size: «touple.size»''')

-                }

-        }

-        

-        private dispatch def transformConstraint(Equality equality, Modality modality) {

-                val a = equality.who

-                val b = equality.withWhom

-                transformEquality(modality.toMustMay, a, b)

-        }

-        

-        private def CharSequence transformEquality(Modality modality, PVariable a, PVariable b) {

-                if(modality.isMustOrCurrent) '''find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''

-                else '''find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''

-        }       

-        

-        private dispatch def transformConstraint(Inequality inequality, Modality modality) {

-                val a = inequality.who

-                val b = inequality.withWhom

-                if(modality.isCurrent) {

-                        return '''neg find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''

-                } else if(modality.isMust) {

-                        return '''neg find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''

-                } else { // modality.isMay

-                        return '''neg find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''

-                }

-        }

-        

-        private dispatch def transformConstraint(NegativePatternCall pcall, Modality modality) {

-                val params = (0..<pcall.actualParametersTuple.size).map[index | 

-                        val variable = pcall.actualParametersTuple.get(index) as PVariable

-                        return variable.canonizeName

-                ]

-                return referPattern(pcall.referredQuery,params,modality.dual,false,false)

-        }

-        

-        private dispatch def transformConstraint(PositivePatternCall pcall, Modality modality) {

-                val params = (0..<pcall.variablesTuple.size).map[index | 

-                        val variable = pcall.variablesTuple.get(index) as PVariable

-                        return variable.canonizeName

-                ]

-                return referPattern(pcall.referredQuery,params,modality,true,false)

-        }

-        private dispatch def transformConstraint(BinaryTransitiveClosure pcall, Modality modality) {

-                val params = (0..1).map[index | 

-                        val variable = pcall.getVariableInTuple(index) as PVariable

-                        return variable.canonizeName

-                ]

-                return referPattern(pcall.referredQuery,params,modality,true,true)

-        }

-        private dispatch def transformConstraint(ExportedParameter e, Modality modality) {

-                return '''// «e.parameterName» is exported'''

-        }

-        private dispatch def transformConstraint(ConstantValue c, Modality modality) {

-                val target = c.supplierKey

-                

-                var String targetString;

-                var String additionalDefinition;

-                if(target instanceof EEnumLiteral) {

-                        targetString = '''const_«target.name»_«target.EEnum.name»'''

-                        additionalDefinition = '''DefinedElement.name(«targetString»,"«target.name» «target.EEnum.name»");  //LogicProblem.elements(problem,«targetString»);'''

-                } else if(target instanceof Integer) {

-                        targetString = '''const_«target»_Integer'''

-                        additionalDefinition = '''IntegerElement.value(«targetString»,«target»);'''

-                } else if(target instanceof Boolean) {

-                        targetString = '''const_«target»_Boolean'''

-                        additionalDefinition = '''BooleanElement.value(«targetString»,«target»);'''

-                } else if(target instanceof String) {

-                        targetString = '''const_«target»_String'''

-                        additionalDefinition = '''StringElement.value(«targetString»,"«target»");'''

-                } else if(target instanceof Double) {

-                        targetString = '''const_«target»_Number'''

-                        additionalDefinition = '''RealElement.value(«targetString»,"«target»");'''

-                } else if(target instanceof Float) {

-                        targetString = '''const_«target»_Number'''

-                        additionalDefinition = '''RealElement.value(«targetString»,"«target»");'''

-                } else {

-                        throw new UnsupportedOperationException('''Unknown constant type: «target.class»''')

-                }

-                

-                val source = c.variablesTuple

-                var String sourceName

-                if(source.size == 1)

-                        sourceName = (source.get(0) as PVariable).canonizeName

-                else throw new UnsupportedOperationException("unknown source")

-                return '''«sourceName» == «targetString»;«additionalDefinition»''';

-        }

-        

-        private dispatch def transformConstraint(PConstraint c, Modality modality) {

-                throw new UnsupportedOperationException('''Unknown constraint type: "«c.class.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/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..6f5f2402 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
@@ -1,85 +1,93 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

 

+import com.google.common.collect.ImmutableList

+import com.google.common.collect.ImmutableMap

+import com.google.common.collect.ImmutableSet

 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.logicproblem.LogicProblem

 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality

+import java.util.Collection

 import java.util.LinkedList

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference

+import java.util.Map

+import java.util.Set

+import org.eclipse.xtend2.lib.StringConcatenationClient

 

 class RelationRefinementGenerator {

         PatternGenerator base;

-        public new(PatternGenerator base) {

+

+        new(PatternGenerator base) {

                 this.base = base

         }

-        

-        def CharSequence generateRefineReference(LogicProblem p) {

-                return '''

-                «FOR relationRefinement: this.getRelationRefinements(p)»

-                pattern «relationRefinementQueryName(relationRefinement.key,relationRefinement.value)»(

-                        problem:LogicProblem, interpretation:PartialInterpretation,

-                        relationIterpretation:PartialRelationInterpretation«IF relationRefinement.value != null», oppositeInterpretation:PartialRelationInterpretation«ENDIF»,

-                        from: DefinedElement, to: DefinedElement)

-                {

-                        find interpretation(problem,interpretation);

-                        PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);

-                        PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«relationRefinement.key.name»");

-                        «IF relationRefinement.value != null»

-                                PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation);

-                                PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"«relationRefinement.value.name»");

-                        «ENDIF»

-                        find mustExist(problem, interpretation, from);

-                        find mustExist(problem, interpretation, to);

-                        «base.typeIndexer.referInstanceOfByReference(relationRefinement.key.parameters.get(0), Modality::MUST,"from")»

-                        «base.typeIndexer.referInstanceOfByReference(relationRefinement.key.parameters.get(1), Modality::MUST,"to")»

-                        «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MAY)»

-                        neg «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MUST)»

-                }

-                «ENDFOR»

+

+        def CharSequence generateRefineReference(LogicProblem p,

+                Collection<UnitPropagationPatternGenerator> unitPropagationPatternGenerators) {

+                val mustRelations = getMustRelations(unitPropagationPatternGenerators)

+

+                '''

+                        «FOR relationRefinement : this.getRelationRefinements(p)»

+                                pattern «relationRefinementQueryName(relationRefinement.key,relationRefinement.value)»(

+                                        problem:LogicProblem, interpretation:PartialInterpretation,

+                                        relationIterpretation:PartialRelationInterpretation«IF relationRefinement.value !== null», oppositeInterpretation:PartialRelationInterpretation«ENDIF»,

+                                        from: DefinedElement, to: DefinedElement)

+                                {

+                                        find interpretation(problem,interpretation);

+                                        PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);

+                                        PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«relationRefinement.key.name»");

+                                        «IF relationRefinement.value !== null»

+                                                PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation);

+                                                PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"«relationRefinement.value.name»");

+                                        «ENDIF»

+                                        find mustExist(problem, interpretation, from);

+                                        find mustExist(problem, interpretation, to);

+                                        «base.typeIndexer.referInstanceOfByReference(relationRefinement.key.parameters.get(0), Modality::MUST,"from")»

+                                        «base.typeIndexer.referInstanceOfByReference(relationRefinement.key.parameters.get(1), Modality::MUST,"to")»

+                                        «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MAY)»

+                                        neg «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MUST)»

+                                }

+                                

+                                «IF isMustPropagationQueryNeeded(relationRefinement.key, relationRefinement.value, mustRelations)»

+                                        pattern «mustPropagationQueryName(relationRefinement.key)»(

+                                                problem:LogicProblem, interpretation:PartialInterpretation,

+                                                relationIterpretation:PartialRelationInterpretation«IF relationRefinement.value !== null», oppositeInterpretation:PartialRelationInterpretation«ENDIF»,

+                                                from: DefinedElement, to: DefinedElement)

+                                        «FOR body : getMustPropagationBodies(relationRefinement.key, relationRefinement.value, mustRelations) SEPARATOR " or "»

+                                                {

+                                                        «referRefinementQuery(relationRefinement.key, relationRefinement.value, "relationIterpretation", "oppositeInterpretation", "from", "to")»

+                                                        «body»

+                                                }

+                                        «ENDFOR»

+                                «ENDIF»

+                        «ENDFOR»

                 '''

         }

-        

+

         def String relationRefinementQueryName(RelationDeclaration relation, Relation inverseRelation) {

-                '''«IF inverseRelation != null

-                »refineRelation_«base.canonizeName(relation.name)»_and_«base.canonizeName(inverseRelation.name)»«

-                        ELSE

-                »refineRelation_«base.canonizeName(relation.name)»«ENDIF»'''

+                '''«IF inverseRelation !== null»refineRelation_«base.canonizeName(relation.name)»_and_«base.canonizeName(inverseRelation.name)»«ELSE»refineRelation_«base.canonizeName(relation.name)»«ENDIF»'''

         }

-        

+

+        def String mustPropagationQueryName(RelationDeclaration relation) {

+                '''mustPropagation_«base.canonizeName(relation.name)»'''

+        }

+

         def referRefinementQuery(RelationDeclaration relation, Relation inverseRelation, String relInterpretationName,

-                String inverseInterpretationName, String sourceName, String targetName)

-        '''find «this.relationRefinementQueryName(relation,inverseRelation)»(problem, interpretation, «relInterpretationName», «IF inverseRelation != null»inverseInterpretationName, «ENDIF»«sourceName», «targetName»);'''

-        

+                String inverseInterpretationName, String sourceName,

+                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

-                for(relation: getRelationRefinements(p)) {

-                        if(inverseRelations.containsKey(relation)) {

-                                val name = '''refineRelation_«base.canonizeName(relation.name)»_and_«base.canonizeName(inverseRelations.get(relation).name)»'''

-                                res.put(relation -> inverseRelations.get(relation),name)

-                        } else {

-                                val name = '''refineRelation_«base.canonizeName(relation.name)»'''

-                                res.put(relation -> null,name)

-                        }

-                }

-                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)) {

-                        if(!containments.contains(relation)) {

-                                if(inverses.containsKey(relation)) {

+                for (relation : p.relations.filter(RelationDeclaration)) {

+                        if (!containments.contains(relation)) {

+                                if (inverses.containsKey(relation)) {

                                         val inverse = inverses.get(relation)

-                                        if(!containments.contains(inverse)) {

-                                                if(base.isRepresentative(relation,inverse)) {

+                                        if (!containments.contains(inverse)) {

+                                                if (base.isRepresentative(relation, inverse)) {

                                                         list += (relation -> inverse)

                                                 }

                                         }

@@ -90,4 +98,54 @@ class RelationRefinementGenerator {
                 }

                 return list

         }

-}
\ No newline at end of file
+

+        def getMustPropagationQueries(LogicProblem p,

+                Collection<UnitPropagationPatternGenerator> unitPropagationPatternGenerators) {

+                val refinements = getRelationRefinements(p)

+                val mustRelations = getMustRelations(unitPropagationPatternGenerators)

+                refinements.filter[isMustPropagationQueryNeeded(key, value, mustRelations)].toInvertedMap [

+                        mustPropagationQueryName(key)

+                ]

+        }

+

+        private def getMustRelations(Collection<UnitPropagationPatternGenerator> unitPropagationPatternGenerators) {

+                ImmutableMap.copyOf(unitPropagationPatternGenerators.flatMap[mustPatterns.entrySet].groupBy[key].mapValues [

+                        ImmutableSet.copyOf(map[value])

+                ])

+        }

+

+        private def isMustPropagationQueryNeeded(Relation relation, Relation inverseRelation,

+                Map<Relation, ? extends Set<String>> mustRelations) {

+                val mustSet = mustRelations.get(relation)

+                if (mustSet !== null && !mustSet.empty) {

+                        return true

+                }

+                if (inverseRelation !== null) {

+                        val inverseMustSet = mustRelations.get(inverseRelation)

+                        if (inverseMustSet !== null && !inverseMustSet.empty) {

+                                return true

+                        }

+                }

+                false

+        }

+

+        private def getMustPropagationBodies(Relation relation, Relation inverseRelation,

+                Map<Relation, ? extends Set<String>> mustRelations) {

+                val builder = ImmutableList.<StringConcatenationClient>builder()

+                val mustSet = mustRelations.get(relation)

+                if (mustSet !== null) {

+                        for (refinementQuery : mustSet) {

+                                builder.add('''find «refinementQuery»(problem, interpretation, from, to);''')

+                        }

+                }

+                if (inverseRelation !== null && inverseRelation != relation) {

+                        val inverseMustSet = mustRelations.get(inverseRelation)

+                        if (inverseMustSet !== null) {

+                                for (refinementQuery : inverseMustSet) {

+                                        builder.add('''find «refinementQuery»(problem, interpretation, to, from);''')

+                                }

+                        }

+                }

+                builder.build

+        }

+}

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 d1d57189..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,52 +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()

-        public def boolean requiresTypeAnalysis()

-        public def CharSequence generateInstanceOfQueries(LogicProblem problem,PartialInterpretation emptySolution,TypeAnalysisResult typeAnalysisResult)

-        public def CharSequence referInstanceOf(Type type, Modality modality, String variableName)

-        public def CharSequence referInstanceOf(EClass type, Modality modality, String variableName)

-        

-        public def dispatch CharSequence referInstanceOfByReference(ComplexTypeReference reference, Modality modality, String variableName) {

-                reference.referred.referInstanceOf(modality,variableName)

-        }

-        public def dispatch CharSequence referInstanceOfByReference(BoolTypeReference reference, Modality modality, String variableName) {

+        @Accessors(PROTECTED_GETTER) val PatternGenerator base

+

+        def CharSequence getRequiredQueries() '''

+                private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) {

+                        find interpretation(problem,interpretation);

+                        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);

+                }

+        '''

+

+        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»");'''

         }

 

-}
\ No newline at end of file
+        def CharSequence referPrimitiveFilled(String variableName, boolean isFilled) {

+                '''PrimitiveElement.valueSet(«variableName»,«isFilled»);'''

+        }

+}

+

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{

-        val PatternGenerator base;

-        

+class TypeIndexerWithPreliminaryTypeAnalysis extends TypeIndexer {

         new(PatternGenerator base) {

-                this.base = base

+                super(base)

         }

+

         override requiresTypeAnalysis() { true }

-        

-        override getRequiredQueries() '''

-        private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) {

-                find interpretation(problem,interpretation);

-                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

-                }

+

+        protected override generateMayInstanceOf(LogicProblem problem, Type type, TypeAnalysisResult typeAnalysisResult) {

+                val precondition = typeAnalysisResult?.mayNewTypePreconditions?.get(type)

+                val inhibitorTypes = precondition?.inhibitorTypes

                 '''

-                private pattern scopeDisallowsNew«base.canonizeName(type.name)»(problem:LogicProblem, interpretation:PartialInterpretation) {

-                        find interpretation(problem,interpretation);

-                        PartialInterpretation.scopes(interpretation,scope);

-                        Scope.targetTypeInterpretation(scope,typeInterpretation);

-                        Scope.maxNewElements(scope,0);

-                        PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type);

-                        Type.name(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)

-                «IF inhibitorTypes !== null»{

-                        find interpretation(problem,interpretation);

-                        PartialInterpretation.newElements(interpretation,element);

-                        «FOR inhibitorType : inhibitorTypes»

-                                neg «referInstanceOf(inhibitorType,Modality.MUST,"element")»

-                        «ENDFOR»

-                        neg find scopeDisallowsNew«base.canonizeName(type.name)»(problem, interpretation);

-                        neg find isPrimitive(element);

-                } or {

-                        find interpretation(problem,interpretation);

-                        PartialInterpretation.openWorldElements(interpretation,element);

-                        «FOR inhibitorType : inhibitorTypes»

-                                neg «referInstanceOf(inhibitorType,Modality.MUST,"element")»

-                        «ENDFOR»

-                        neg find scopeDisallowsNew«base.canonizeName(type.name)»(problem, interpretation);

-                        neg find isPrimitive(element);

-                } or

-                «ENDIF»

-                { «referInstanceOf(type,Modality.MUST,"element")» }

+                        private pattern scopeDisallowsNew«base.canonizeName(type.name)»(problem:LogicProblem, interpretation:PartialInterpretation) {

+                                find interpretation(problem,interpretation);

+                                PartialInterpretation.scopes(interpretation,scope);

+                                Scope.targetTypeInterpretation(scope,typeInterpretation);

+                                Scope.maxNewElements(scope,0);

+                                PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type);

+                                Type.name(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)

+                        «IF inhibitorTypes !== null»

+                                {

+                                        find interpretation(problem,interpretation);

+                                        PartialInterpretation.newElements(interpretation,element);

+                                        «FOR inhibitorType : inhibitorTypes»

+                                                neg «referInstanceOf(inhibitorType,Modality.MUST,"element")»

+                                        «ENDFOR»

+                                        neg find scopeDisallowsNew«base.canonizeName(type.name)»(problem, interpretation);

+                                        neg find isPrimitive(element);

+                                } or {

+                                        find interpretation(problem,interpretation);

+                                        PartialInterpretation.openWorldElements(interpretation,element);

+                                        «FOR inhibitorType : inhibitorTypes»

+                                                neg «referInstanceOf(inhibitorType,Modality.MUST,"element")»

+                                        «ENDFOR»

+                                        neg find scopeDisallowsNew«base.canonizeName(type.name)»(problem, interpretation);

+                                        neg find isPrimitive(element);

+                                } or

+                        «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()

-        public def CharSequence generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult)

-        public def CharSequence generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult)

-        public def Map<? extends Type, String> getRefineTypeQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult)

-        

-        public def getRefineObjectQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {

-                val Map<ObjectCreationPrecondition,String> objectCreationQueries = new LinkedHashMap

+

+        def boolean requiresTypeAnalysis()

+

+        def CharSequence generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution,

+                TypeAnalysisResult typeAnalysisResult)

+

+        def CharSequence generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution,

+                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[

-                        inverseRelations.put(it.inverseA,it.inverseB)

-                        inverseRelations.put(it.inverseB,it.inverseA)

+                p.annotations.filter(InverseRelationAssertion).forEach [

+                        inverseRelations.put(it.inverseA, it.inverseB)

+                        inverseRelations.put(it.inverseB, it.inverseA)

                 ]

-                for(type: p.types.filter(TypeDeclaration).filter[!it.isAbstract]) {

-                        if(containment.typeInContainment(type)) {

-                                for(containmentRelation : containment.containmentRelations.filter[canBeContainedByRelation(it,type)]) {

-                                        if(inverseRelations.containsKey(containmentRelation)) {

+                for (type : p.types.filter(TypeDeclaration).filter[!it.isAbstract]) {

+                        if (containment.typeInContainment(type)) {

+                                for (containmentRelation : containment.containmentRelations.

+                                        filter[canBeContainedByRelation(it, type)]) {

+                                        if (inverseRelations.containsKey(containmentRelation)) {

                                                 objectCreationQueries.put(

-                                                        new ObjectCreationPrecondition(containmentRelation,inverseRelations.get(containmentRelation),type),

-                                                        this.patternName(containmentRelation,inverseRelations.get(containmentRelation),type))

+                                                        new ObjectCreationPrecondition(containmentRelation,

+                                                                inverseRelations.get(containmentRelation), type),

+                                                        this.patternName(containmentRelation, inverseRelations.get(containmentRelation), type))

                                         } else {

-                                                objectCreationQueries.put(

-                                                        new ObjectCreationPrecondition(containmentRelation,null,type),

-                                                        patternName(containmentRelation,null,type))

+                                                objectCreationQueries.put(new ObjectCreationPrecondition(containmentRelation, null, type),

+                                                        patternName(containmentRelation, null, type))

                                         }

                                 }

-                                objectCreationQueries.put(

-                                        new ObjectCreationPrecondition(null,null,type),

-                                        patternName(null,null,type))

+                                objectCreationQueries.put(new ObjectCreationPrecondition(null, null, type),

+                                        patternName(null, null, type))

                         } else {

-                                objectCreationQueries.put(

-                                        new ObjectCreationPrecondition(null,null,type),

-                                        this.patternName(null,null,type))

+                                objectCreationQueries.put(new ObjectCreationPrecondition(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(inverseContainment != null) {

+                if (containmentRelation !== 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 ad1c9033..65ad3d48 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,149 @@
 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

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference

+

+@Data

+class UnifinishedMultiplicityQueryNames {

+        val String existingMultiplicityQueryName

+        val String existingInverseMultiplicityQueryName

+}

 

 class UnfinishedIndexer {

         val PatternGenerator base

-        

-        new(PatternGenerator patternGenerator) {

+        val boolean indexUpperMultiplicities

+

+        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»

-                        pattern unfinishedBy_«base.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation,

-                                «FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)

-                        {

-                                «base.relationDefinitionIndexer.referPattern(

+                        «FOR wfQuery : wfQueries»

+                                pattern unfinishedBy_«base.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation,

+                                        «FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)

+                                {

+                                        «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) {

-                        map.put(wfQuery.target,'''unfinishedBy_«base.canonizeName(wfQuery.target.name)»''')

+                for (wfQuery : wfQueries) {

+                        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)

-                return '''

-                «FOR lowerMultiplicity : lowerMultiplicities»

-                        pattern «unfinishedMultiplicityName(lowerMultiplicity)»(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) {

-                                find interpretation(problem,interpretation);

-                                PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);

-                                PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«lowerMultiplicity.relation.name»");

-                                «base.typeIndexer.referInstanceOf(lowerMultiplicity.firstParamTypeOfRelation,Modality::MUST,"object")»

-                                numberOfExistingReferences == count «base.referRelation(lowerMultiplicity.relation,"object","_",Modality.MUST,fqn2PQuery)»

-                                check(numberOfExistingReferences < «lowerMultiplicity.lower»);

-                                missingMultiplicity == eval(«lowerMultiplicity.lower»-numberOfExistingReferences);

-                        }

+

+        def generateUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints,

+                Map<String, PQuery> fqn2PQuery) '''

+                «FOR constraint : constraints»

+                        «IF constraint.shouldIndexExistingMultiplicites(indexUpperMultiplicities)»

+                                private pattern «existingMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, numberOfExistingReferences:java Integer«IF constraint.shouldIndexRepairMultiplcities(indexUpperMultiplicities)», numberOfRepairMatches: java Integer«ENDIF») {

+                                        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)»

+                                        «IF constraint.shouldIndexRepairMultiplcities(indexUpperMultiplicities)»

+                                                numberOfRepairMatches == count find «repairMatchName(constraint)»(problem, interpretation, object, _);

+                                        «ENDIF»

+                                }

+                        «ENDIF»

+                        

+                        «IF constraint.shouldIndexRepairMatches(indexUpperMultiplicities)»

+                                private pattern «repairMatchName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, source:DefinedElement, target:DefinedElement) {

+                                        «IF constraint.containment || constraint.container»

+                                                «repairMatchFallback(constraint, fqn2PQuery)»

+                                        «ELSEIF base.isRepresentative(constraint.relation, constraint.inverseRelation) && constraint.relation instanceof RelationDeclaration»

+                                                «base.relationRefinementGenerator.referRefinementQuery(constraint.relation as RelationDeclaration, constraint.inverseRelation, "_", "_", "source", "target")»

+                                        «ELSEIF base.isRepresentative(constraint.inverseRelation, constraint.relation) && constraint.inverseRelation instanceof RelationDeclaration»

+                                                «base.relationRefinementGenerator.referRefinementQuery(constraint.inverseRelation as RelationDeclaration, constraint.relation, "_", "_", "target", "source")»

+                                        «ELSE»

+                                                «repairMatchFallback(constraint, fqn2PQuery)»

+                                        «ENDIF»

+                                }

+                        «ENDIF»

+                        

+                        «IF constraint.shouldIndexInverseMultiplicites(indexUpperMultiplicities)»

+                                private pattern «existingInverseMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, numberOfExistingReferences:java Integer, numberOfRepairMatches: 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)»

+                                        numberOfRepairMatches == count find «repairMatchName(constraint)»(problem, interpretation, _, object);

+                                }

+                        «ENDIF»

                 «ENDFOR»

-                '''

+        '''

+

+        private def repairMatchFallback(RelationMultiplicityConstraint constraint, Map<String, PQuery> fqn2PQuery) '''

+                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)»

+        '''

+

+        def String existingMultiplicityName(

+                RelationMultiplicityConstraint constraint) '''existingMultiplicity_«base.canonizeName(constraint.relation.name)»'''

+

+        def String existingInverseMultiplicityName(

+                RelationMultiplicityConstraint constraint) '''existingInverseMultiplicity_«base.canonizeName(constraint.relation.name)»'''

+

+        private def String repairMatchName(

+                RelationMultiplicityConstraint constraint) '''repair_«base.canonizeName(constraint.relation.name)»'''

+

+        def getUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints) {

+                constraints.toInvertedMap [ constraint |

+                        new UnifinishedMultiplicityQueryNames(

+                                if (constraint.shouldIndexExistingMultiplicites(indexUpperMultiplicities)) {

+                                        existingMultiplicityName(constraint)

+                                } else {

+                                        null

+                                },

+                                if (constraint.shouldIndexInverseMultiplicites(indexUpperMultiplicities)) {

+                                        existingInverseMultiplicityName(constraint)

+                                } else {

+                                        null

+                                }

+                        )

+                ]

         }

-        def String unfinishedMultiplicityName(LowerMultiplicityAssertion lowerMultiplicityAssertion) 

-                '''unfinishedLowerMultiplicity_«base.canonizeName(lowerMultiplicityAssertion.relation.name)»'''

-        

-        def public referUnfinishedMultiplicityQuery(LowerMultiplicityAssertion lowerMultiplicityAssertion)

-                '''find «unfinishedMultiplicityName(lowerMultiplicityAssertion)»(problem, interpretation ,object, missingMultiplicity);'''

-        

-        def getFirstParamTypeOfRelation(LowerMultiplicityAssertion lowerMultiplicityAssertion) {

-                val parameters = lowerMultiplicityAssertion.relation.parameters

-                if(parameters.size == 2) {

-                        val firstParam = parameters.get(0)

-                        if(firstParam instanceof ComplexTypeReference) {

-                                return firstParam.referred

-                        }

-                }

+

+        static def shouldIndexExistingMultiplicites(RelationMultiplicityConstraint it, boolean indexUpperMultiplicities) {

+                constrainsUnfinished || (indexUpperMultiplicities && constrainsRemainingContents)

         }

-        

-        def getUnfinishedMultiplicityQueries(LogicProblem problem) {

-                val lowerMultiplicities = base.lowerMultiplicities(problem)

-                val map = new LinkedHashMap

-                for(lowerMultiplicity : lowerMultiplicities) {

-                        map.put(lowerMultiplicity.relation,unfinishedMultiplicityName(lowerMultiplicity))

-                }

-                return map

+

+        static def shouldIndexRepairMultiplcities(RelationMultiplicityConstraint it, boolean indexUpperMultiplicities) {

+                shouldIndexExistingMultiplicites(indexUpperMultiplicities) && constrainsUnrepairable

+        }

+

+        static def shouldIndexInverseMultiplicites(RelationMultiplicityConstraint it, boolean indexUpperMultiplicities) {

+                indexUpperMultiplicities && constrainsRemainingInverse

+        }

+

+        static def shouldIndexRepairMatches(RelationMultiplicityConstraint it, boolean indexUpperMultiplicities) {

+                shouldIndexRepairMultiplcities(indexUpperMultiplicities) ||

+                        shouldIndexInverseMultiplicites(indexUpperMultiplicities)

         }

 }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnitPropagationPreconditionGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnitPropagationPreconditionGenerator.xtend
new file mode 100644
index 00000000..400f47bc
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnitPropagationPreconditionGenerator.xtend
@@ -0,0 +1,302 @@
+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.RelationDefinition

+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.Modality

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.PropagationModality

+import java.util.Map

+import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint

+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExpressionEvaluation

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery

+

+import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

+import java.util.LinkedList

+import java.util.List

+import org.eclipse.xtend.lib.annotations.Data

+import java.util.HashMap

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall

+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall

+import java.util.Comparator

+import java.util.ArrayList

+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PDisjunction

+import java.util.LinkedHashSet

+

+@Data class UnitPropagation {

+        val PQuery q

+        val PConstraint c

+        val PropagationModality pm

+        val Modality m3

+}

+@Data

+class UnitPropagationPreconditionGenerationResult {

+        List<CharSequence> definitions= new LinkedList

+        Map<UnitPropagation,String> unitPropagation2PatternName = new HashMap

+        Map<PConstraint,String> constraintOccurence2Name = new HashMap

+        

+        def registerQuery(PQuery q, PConstraint c, PropagationModality pm, Modality m3, String patternName, CharSequence definition) {

+                val key = new UnitPropagation(q,c,pm,m3)

+                definitions += definition

+                unitPropagation2PatternName.put(key,patternName)

+        }

+        def registerUnsatQuery(PQuery q, PConstraint c, PropagationModality pm, Modality m3) {

+                val key = new UnitPropagation(q,c,pm,m3)

+                unitPropagation2PatternName.put(key,null)

+        }

+        def contains(PQuery q, PConstraint c, PropagationModality pm, Modality m3) {

+                val key = new UnitPropagation(q,c,pm,m3)

+                return unitPropagation2PatternName.containsKey(key)

+        }

+        def getName(PQuery q, PConstraint c, PropagationModality pm, Modality m3) {

+                val key = new UnitPropagation(q,c,pm,m3)

+                return key.lookup(unitPropagation2PatternName)

+        }

+        def isDefined(PQuery q, PConstraint c, PropagationModality pm, Modality m3) {

+                val key = new UnitPropagation(q,c,pm,m3)

+                return unitPropagation2PatternName.get(key) !== null

+        }

+}

+@Data

+class UnitPropagationPreconditionFinalResult {

+        CharSequence definitions

+        HashMap<PConstraint,String> constraint2MustPreconditionName

+        HashMap<PConstraint,String> constraint2CurrentPreconditionName

+}

+

+class UnitPropagationPreconditionGenerator {

+        val PatternGenerator base

+        val PConstraintTransformer constraintTransformer;

+        

+        new(PatternGenerator patternGenerator) {

+                this.base = patternGenerator

+                this.constraintTransformer = new PConstraintTransformer(base.relationDefinitionIndexer)

+        }

+        

+        def generateUnitPropagationRules(

+                LogicProblem problem,

+                Iterable<RelationDefinition> relations,

+                Map<String,PQuery> fqn2PQuery)

+        {

+                // Create an empty result

+                val res = new UnitPropagationPreconditionGenerationResult               

+                val wfs = base.wfQueries(problem)//.map[it.patternPQuery]

+                val Map<PConstraint,List<Pair<String,Integer>>> mainMustPropagationNames = new HashMap

+                val Map<PConstraint,List<Pair<String,Integer>>> mainCurrentPropagationNames = new HashMap

+                for(wf : wfs) {

+                        val query = wf.patternPQuery as PQuery

+                        val relation = wf.target

+                        val allReferredChecks = allReferredConstraints(relation,query).filter(ExpressionEvaluation)

+                        

+                        for(referredCheck : allReferredChecks) {

+                                val mustPropagationPrecondition = getOrGeneratePropagationRule(res,relation,query,referredCheck,PropagationModality::UP, Modality::MUST)

+                                val currentPropagationPrecondition = getOrGeneratePropagationRule(res,relation,query,referredCheck,PropagationModality::UP, Modality::CURRENT)

+                                if(!mainMustPropagationNames.containsKey(referredCheck)) {

+                                        mainMustPropagationNames.put(referredCheck,new LinkedList)

+                                }

+                                if(!mainCurrentPropagationNames.containsKey(referredCheck)) {

+                                        mainCurrentPropagationNames.put(referredCheck,new LinkedList)

+                                }

+                                if(mustPropagationPrecondition !== null) {

+                                        mainMustPropagationNames.get(referredCheck).add(mustPropagationPrecondition->query.parameterNames.size)

+                                }

+                                if(currentPropagationPrecondition !== null) {

+                                        mainCurrentPropagationNames.get(referredCheck).add(currentPropagationPrecondition->query.parameterNames.size)

+                                }

+                        }

+                }

+                val preconditions = new LinkedList

+                val constraint2MustPrecondition = new HashMap

+                val constraint2CurrentPrecondition = new HashMap

+                for(entry : mainMustPropagationNames.entrySet) {

+                        val name = '''UPMUSTPropagate_«res.getOrGenerateConstraintName(entry.key)»''';

+                        val def = '''

+                        pattern «name»(«FOR index : 1..entry.key.arity SEPARATOR ", "»«canonizeName(index,PropagationModality::UP)»«ENDFOR»)

+                                «FOR propagation : entry.value SEPARATOR " or "»

+                                        { find «propagation.key»(problem,interpretation,«FOR index : 0..<propagation.value SEPARATOR ','»_«ENDFOR»,«FOR index : 1..entry.key.arity SEPARATOR ", "»«canonizeName(index,PropagationModality::UP)»«ENDFOR»); }

+                                «ENDFOR»'''

+                        preconditions+=def

+                        constraint2MustPrecondition.put(entry.key,name)

+                }

+                for(entry : mainCurrentPropagationNames.entrySet) {

+                        val name = '''UPCurrentPropagate_«res.getOrGenerateConstraintName(entry.key)»''';

+                        val def = '''

+                        pattern «name»(«FOR index : 1..entry.key.arity SEPARATOR ", "»«canonizeName(index,PropagationModality::UP)»«ENDFOR»)

+                                «FOR propagation : entry.value SEPARATOR " or "»

+                                        { find «propagation.key»(problem,interpretation,«FOR index : 0..<propagation.value SEPARATOR ','»_«ENDFOR»,«FOR index : 1..entry.key.arity SEPARATOR ", "»«canonizeName(index,PropagationModality::UP)»«ENDFOR»); }

+                                «ENDFOR»'''

+                        preconditions+=def

+                        constraint2CurrentPrecondition.put(entry.key,name)

+                }

+                

+                val definitions = '''

+                        «FOR def : res.definitions»

+                                «def»

+                        «ENDFOR»

+                        

+                        // Collected propagation preconditions:

+                        

+                        «FOR predondition : preconditions»

+                                «predondition»

+                        «ENDFOR»

+                '''

+                return new UnitPropagationPreconditionFinalResult(definitions,constraint2MustPrecondition,constraint2CurrentPrecondition)

+        }

+        def allReferredConstraints(Relation relation, PQuery query) {

+                val allReferredQueries = query.allReferredQueries

+                val problem = relation.eContainer as LogicProblem

+                val constraints = new LinkedHashSet

+                for(referredQuery: #[query]+allReferredQueries) {

+                        val referredRelation = problem.annotations.filter(TransfomedViatraQuery).filter[it.patternPQuery === referredQuery].head.target

+                        val bodies = (referredRelation.annotations.filter(TransfomedViatraQuery).head.optimizedDisjunction as PDisjunction).bodies

+                        constraints.addAll(bodies.map[getConstraints].flatten)

+                }

+                

+                return constraints

+        }

+        

+        def getOrGeneratePropagationRule(UnitPropagationPreconditionGenerationResult res, Relation relation, PQuery q, PConstraint c, PropagationModality pm, Modality m3) {

+                if(res.contains(q,c,pm,m3)) {

+                        return res.getName(q,c,pm,m3)

+                } else {

+                        res.generatePropagationRule(relation,q,c,pm,m3)

+                        return res.getName(q,c,pm,m3)

+                }

+        }

+        def getOrGenerateConstraintName(UnitPropagationPreconditionGenerationResult res, PConstraint c){

+                if(res.constraintOccurence2Name.containsKey(c)) {

+                        return res.constraintOccurence2Name.get(c)

+                } else {

+                        val constraintName = '''Constraint«res.constraintOccurence2Name.size»'''

+                        res.constraintOccurence2Name.put(c,constraintName)

+                        return constraintName

+                }

+        }

+        

+        def void generatePropagationRule(UnitPropagationPreconditionGenerationResult res, Relation relation, PQuery q, PConstraint c, PropagationModality pm, Modality m3) {

+                val name = relationDefinitionName(res,relation,q,c,pm,m3)

+                val constraintArity = c.arity

+                val bodies = (relation.annotations.filter(TransfomedViatraQuery).head.optimizedDisjunction as PDisjunction).bodies

+                val generatedBodies = new LinkedList

+                for(body : bodies) {

+                        if(body.constraints.contains(c)) {

+                                if(pm === PropagationModality::UP) {

+                                        generatedBodies += '''

+                                                // Original Constraints

+                                                «FOR constraint : body.constraints.filter[it !== c]»

+                                                        «this.constraintTransformer.transformConstraint(constraint,m3,relation.annotations.filter(TransfomedViatraQuery).head.variableTrace)»

+                                                «ENDFOR»

+                                                // Propagation for constraint

+                                                «this.constraintTransformer.transformConstraintUnset(c as ExpressionEvaluation,relation.annotations.filter(TransfomedViatraQuery).head.variableTrace)»

+                                                // Matching variables

+                                                «this.propagateVariables(c,pm)»

+                                        '''

+                                }

+                                // Otherwise, for PropagationModality::DOWN, the body cannot be satisfied

+                        } else {

+                                val positives = body.constraints.filter(PositivePatternCall)

+                                for(positive: positives) {

+                                        val referredPQuery = positive.referredQuery

+                                        val referredRelation = (relation.eContainer as LogicProblem)

+                                                .annotations.filter(TransfomedViatraQuery).filter[it.patternPQuery === referredPQuery].head.target

+                                        if(allReferredConstraints(referredRelation,referredPQuery).toSet.contains(c)) {

+                                                val referredName = getOrGeneratePropagationRule(res,referredRelation,referredPQuery,c,pm,m3)

+                                                if(referredName !== null) {

+                                                        generatedBodies += '''

+                                                                // Original Constraints

+                                                                «FOR constraint : body.constraints.filter[it !== positive]»

+                                                                        «this.constraintTransformer.transformConstraint(constraint,m3,relation.annotations.filter(TransfomedViatraQuery).head.variableTrace)»

+                                                                «ENDFOR»

+                                                                // Propagation for constraint referred indirectly from this pattern through «referredName»

+                                                                find «referredName»(problem, interpretation,

+                                                                        «FOR index : 0..<referredPQuery.parameters.size SEPARATOR ", "»«positive.getVariableInTuple(index).canonizeName»«ENDFOR»,

+                                                                        «FOR index : 1..c.arity SEPARATOR ", "»«canonizeName(index,pm)»«ENDFOR»);

+                                                        '''

+                                                }

+                                                // Otherwise, if the referred pattern is not satisfiable, this pattern is not satisfiable either

+                                        }

+                                }

+                                

+                                val negatives = body.constraints.filter(NegativePatternCall)

+                                for(negative : negatives) {

+                                        val referredPQuery = negative.referredQuery

+                                        val referredRelation = (relation.eContainer as LogicProblem)

+                                                .annotations.filter(TransfomedViatraQuery).filter[it.patternPQuery === referredPQuery].head.target

+                                        if(allReferredConstraints(referredRelation,referredPQuery).toSet.contains(c)) {

+                                                val referredName = getOrGeneratePropagationRule(res,referredRelation,referredPQuery,c,pm,m3.dual)

+                                                if(referredName !== null) {

+                                                        generatedBodies += '''

+                                                                // Original Constraints

+                                                                «FOR constraint : body.constraints.filter[it !== negative]»

+                                                                        «this.constraintTransformer.transformConstraint(constraint,m3,relation.annotations.filter(TransfomedViatraQuery).head.variableTrace)»

+                                                                «ENDFOR»

+                                                                // Propagation for constraint referred indirectly from this pattern through «referredName»

+                                                                find «referredName»(problem, interpretation,

+                                                                        «FOR index : 0..<referredPQuery.parameters.size SEPARATOR ", "»«(negative.actualParametersTuple.get(index) as PVariable).canonizeName»«ENDFOR»,

+                                                                        «FOR index : 1..c.arity SEPARATOR ", "»«canonizeName(index,pm)»«ENDFOR»);

+                                                        '''

+                                                } else {

+                                                        generatedBodies += '''

+                                                                // Original Constraints

+                                                                «FOR constraint : body.constraints.filter[it !== negative]»

+                                                                        «this.constraintTransformer.transformConstraint(constraint,m3,relation.annotations.filter(TransfomedViatraQuery).head.variableTrace)»

+                                                                «ENDFOR»

+                                                                // Propagation for constraint referred indirectly from this pattern through «referredName»,

+                                                                // which was unsatisfiable

+                                                        '''

+                                                }

+                                        }

+                                }

+                        }

+                }

+                

+                // Register the result

+                if(generatedBodies.empty) {

+                        res.registerUnsatQuery(q,c,pm,m3)

+                } else {

+                        val definition = '''

+                                private pattern «name»(

+                                        problem:LogicProblem, interpretation:PartialInterpretation,

+                                        «FOR param :  q.parameters SEPARATOR ', '»var_«param.name»«ENDFOR»,

+                                        «FOR arity : 1..constraintArity SEPARATOR ', '»«canonizeName(arity,pm)»«ENDFOR»)

+                                «FOR generatedBody: generatedBodies SEPARATOR " or "»{

+                                «generatedBody»

+                                }«ENDFOR»

+                        '''

+                        res.registerQuery(q,c,pm,m3,name,definition)

+                }

+        }

+

+        private def String relationDefinitionName(UnitPropagationPreconditionGenerationResult res, Relation relation, PQuery q, PConstraint c, PropagationModality pm, Modality m3)

+                '''«pm.name»«m3.name»Propagate«res.getOrGenerateConstraintName(c)»_«base.canonizeName(relation.name)»'''

+        

+        def canonizeName(PVariable v) {

+                return '''«IF v.referringConstraints.size == 1»_«ENDIF»var_«v.name.replaceAll("\\W","")»'''

+        }

+        

+        def canonizeName(int index, PropagationModality m) {

+                return '''«m.name.toLowerCase»_«index»'''

+        }

+        

+        def dispatch propagateVariables(ExpressionEvaluation c, PropagationModality m) {

+                val comparator = new Comparator<PVariable>(){

+                        override compare(PVariable o1, PVariable o2) {

+                                o1.name.compareTo(o2.name)

+                        }

+                }

+                val variablesInOrder = new ArrayList(c.affectedVariables)

+                variablesInOrder.toList.sort(comparator)

+                return '''«FOR variableIndex : 1..variablesInOrder.size»«variablesInOrder.get(variableIndex-1).canonizeName»==«canonizeName(variableIndex,m)»;«ENDFOR»'''

+        }

+        def dispatch propagateVariables(PConstraint c, PropagationModality m) {

+                throw new UnsupportedOperationException('''Constraint not supported: «c.class.simpleName»''')

+        }

+        

+        def dispatch arity(ExpressionEvaluation c) {

+                c.affectedVariables.size

+        }

+        def dispatch arity(PConstraint c) {

+                throw new UnsupportedOperationException('''Constraint not supported: «c.class.simpleName»''')

+        }

+}
\ 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/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 e1be2742..732c135d 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,18 +1,89 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules

 

-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.MultiplicityGoalConstraintCalculator

+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.Type

+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem

+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

 

 class GoalConstraintProvider {

-        def public getUnfinishedMultiplicityQueries(GeneratedPatterns patterns) {

-                val multiplicityQueries = patterns.unfinishedMulticiplicityQueries

-                val res = new ArrayList(multiplicityQueries.size)

-                for(multiplicityQuery : multiplicityQueries.entrySet) {

-                        val targetRelationName = multiplicityQuery.key.name

-                        val query = multiplicityQuery.value

-                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query);

+

+        def getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns, boolean calculateObjectCost) {

+                val objectCosts = if (calculateObjectCost) {

+                                calculateMissingObjectCost(p)

+                        } else {

+                                emptyMap

+                        }

+                val res = new ArrayList()

+                for (entry : patterns.multiplicityConstraintQueries.entrySet) {

+                        val constraint = entry.key

+                        if (constraint.constrainsUnfinished) {

+                                val queries = entry.value

+                                val targetRelationName = constraint.relation.name

+                                val query = queries.existingMultiplicityQuery

+                                val containment = constraint.containment

+                                val lowerBound = constraint.lowerBound

+                                val cost = objectCosts.getOrDefault(constraint.relation, 1)

+                                res += new MultiplicityGoalConstraintCalculator(

+                                        targetRelationName,

+                                        query,

+                                        containment,

+                                        lowerBound,

+                                        cost

+                                )

+                        }

                 }

                 return res

         }

-}
\ No newline at end of file
+

+        private 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

+        }

+}

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 20d24b77..dca10baf 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
@@ -1,226 +1,743 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules

 

+import com.google.common.collect.ImmutableList

+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.ComplexTypeReference

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntTypeReference

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguageFactory

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.PrimitiveTypeReference

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealTypeReference

 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.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

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialIntegerInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRealInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialStringInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationFactory

+import java.lang.reflect.Field

+import java.util.HashMap

+import java.util.Iterator

 import java.util.LinkedHashMap

+import java.util.LinkedList

+import java.util.List

+import java.util.Map

+import org.eclipse.viatra.query.runtime.api.AdvancedViatraQueryEngine

 import org.eclipse.viatra.query.runtime.api.GenericPatternMatch

+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.viatra.query.runtime.rete.matcher.ReteBackendFactory

 import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule

 import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRuleFactory

+import org.eclipse.xtend.lib.annotations.Data

+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor

+import org.eclipse.xtext.xbase.lib.Functions.Function0

 

 class RefinementRuleProvider {

-        private extension BatchTransformationRuleFactory factory = new BatchTransformationRuleFactory

-        private extension PartialinterpretationFactory factory2 = PartialinterpretationFactory.eINSTANCE

-        private extension LogiclanguageFactory factory3 = LogiclanguageFactory.eINSTANCE

-        

+        val extension BatchTransformationRuleFactory factory = new BatchTransformationRuleFactory

+        val extension PartialinterpretationFactory factory2 = PartialinterpretationFactory.eINSTANCE

+        val extension LogiclanguageFactory factory3 = LogiclanguageFactory.eINSTANCE

+

         def canonizeName(String name) {

-                return name.replace(' ','_')

+                return name.replace(' ', '_')

         }

-        

-        def LinkedHashMap<ObjectCreationPrecondition, BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>> 

-                createObjectRefinementRules(

-                        GeneratedPatterns patterns,

-                        ScopePropagator scopePropagator,

-                        boolean nameNewElement,

-                        ModelGenerationStatistics statistics

-                )

-        {               

+

+        def createUnitPrulePropagator(LogicProblem p, PartialInterpretation i, GeneratedPatterns patterns,

+                ScopePropagator scopePropagator, ModelGenerationStatistics statistics) {

+                new UnitRulePropagator(p, i, this, scopePropagator, patterns.mustRelationPropagationQueries, statistics)

+        }

+

+        def LinkedHashMap<ObjectCreationPrecondition, BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>> createObjectRefinementRules(

+                LogicProblem p,

+                PartialInterpretation i,

+                GeneratedPatterns patterns,

+                UnitRulePropagator unitRulePropagator,

+                boolean nameNewElement,

+                ModelGenerationStatistics statistics

+        ) {

                 val res = new LinkedHashMap

-                for(LHSEntry: patterns.refineObjectQueries.entrySet) {

+                val recursiveObjectCreation = recursiveObjectCreation(p, i)

+                for (LHSEntry : patterns.refineObjectQueries.entrySet) {

                         val containmentRelation = LHSEntry.key.containmentRelation

                         val inverseRelation = LHSEntry.key.inverseContainment

                         val type = LHSEntry.key.newType

                         val lhs = LHSEntry.value as IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>>

-                        val rule = createObjectCreationRule(containmentRelation,inverseRelation,type,lhs,nameNewElement,scopePropagator,statistics)

-                        res.put(LHSEntry.key,rule)

+                        val rule = createObjectCreationRule(p, containmentRelation, inverseRelation, type,

+                                recursiveObjectCreation.get(type), lhs, nameNewElement, unitRulePropagator, statistics)

+                        res.put(LHSEntry.key, rule)

                 }

                 return res

         }

-        

-        def private createObjectCreationRule(

-                Relation containmentRelation,

-                Relation inverseRelation,

-                Type type,

-                IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs,

-                boolean nameNewElement,

-                ScopePropagator scopePropagator,

-                ModelGenerationStatistics statistics)

-        {

-                val name = '''addObject_«type.name.canonizeName»«

-                                        IF containmentRelation!=null»_by_«containmentRelation.name.canonizeName»«ENDIF»'''

-                //println("Rule created: " + name + "> " + lhs.fullyQualifiedName)

-                val ruleBuilder = factory.createRule

-                                .name(name)

-                                .precondition(lhs)

-                if(containmentRelation != null) {

-                        if(inverseRelation!= null) {

-                                ruleBuilder.action[match |

-                                        //println(name)

+

+        def private createObjectCreationRule(LogicProblem p, Relation containmentRelation, Relation inverseRelation,

+                Type type, List<ObjectCreationInterpretationData> recursiveObjectCreations,

+                IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, boolean nameNewElement,

+                UnitRulePropagator unitRulePropagator, ModelGenerationStatistics statistics) {

+                val name = '''addObject_«type.name.canonizeName»«IF containmentRelation!==null»_by_«containmentRelation.name.canonizeName»«ENDIF»'''

+                val ruleBuilder = factory.createRule(lhs).name(name)

+                if (containmentRelation !== null) {

+                        if (inverseRelation !== null) {

+                                ruleBuilder.action [ match |

+                                        statistics.incrementTransformationCount

+//                                      println(name)

                                         val startTime = System.nanoTime

-                                        //val problem = match.get(0) as LogicProblem

+                                        // val problem = match.get(0) as LogicProblem

                                         val interpretation = match.get(1) as PartialInterpretation

                                         val relationInterpretation = match.get(2) as PartialRelationInterpretation

                                         val inverseRelationInterpretation = match.get(3) as PartialRelationInterpretation

                                         val typeInterpretation = match.get(4) as PartialComplexTypeInterpretation

                                         val container = match.get(5) as DefinedElement

-                                        

-                                        val newElement = createDefinedElement

-                                        if(nameNewElement) {

-                                                newElement.name = '''new «interpretation.newElements.size»'''

-                                        }

-                                        

-                                        // Existence

-                                        interpretation.newElements+=newElement

-                                        /*interpretation.maxNewElements=interpretation.maxNewElements-1

-                                        if(interpretation.minNewElements > 0) {

-                                                interpretation.minNewElements=interpretation.minNewElements-1

-                                        }*/

-                                        

-                                        // Types

-                                        typeInterpretation.elements += newElement

-                                        typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement]

-                                        // ContainmentRelation

-                                        val newLink1 = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement]

-                                        relationInterpretation.relationlinks+=newLink1

-                                        // Inverse Containment

-                                        val newLink2 = factory2.createBinaryElementRelationLink => [it.param1 = newElement it.param2 = container]

-                                        inverseRelationInterpretation.relationlinks+=newLink2

-                                        

-                                        // Scope propagation

-                                        scopePropagator.propagateAdditionToType(typeInterpretation)

-                                        

-                                        statistics.addExecutionTime(System.nanoTime-startTime)

+                                        createObjectActionWithContainmentAndInverse(

+                                                nameNewElement,

+                                                interpretation,

+                                                typeInterpretation,

+                                                container,

+                                                relationInterpretation,

+                                                inverseRelationInterpretation,

+                                                [createDefinedElement],

+                                                recursiveObjectCreations,

+                                                unitRulePropagator

+                                        )

+                                        statistics.addExecutionTime(System.nanoTime - startTime)

+

+                                        unitRulePropagator.propagate

                                 ]

                         } else {

-                                ruleBuilder.action[match |

-                                        //println(name)

+                                ruleBuilder.action [ match |

+                                        statistics.incrementTransformationCount

+//                                      println(name)

                                         val startTime = System.nanoTime

-                                        //val problem = match.get(0) as LogicProblem

+                                        // val problem = match.get(0) as LogicProblem

                                         val interpretation = match.get(1) as PartialInterpretation

                                         val relationInterpretation = match.get(2) as PartialRelationInterpretation

                                         val typeInterpretation = match.get(3) as PartialComplexTypeInterpretation

                                         val container = match.get(4) as DefinedElement

-                                        

-                                        val newElement = createDefinedElement

-                                        if(nameNewElement) {

-                                                newElement.name = '''new «interpretation.newElements.size»'''

-                                        }

-                                        

-                                        // Existence

-                                        interpretation.newElements+=newElement

-                                        /*interpretation.maxNewElements=interpretation.maxNewElements-1

-                                        if(interpretation.minNewElements > 0) {

-                                                interpretation.minNewElements=interpretation.minNewElements-1

-                                        }*/

-                                        

-                                        // Types

-                                        typeInterpretation.elements += newElement

-                                        typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement]

-                                        // ContainmentRelation

-                                        val newLink = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement]

-                                        relationInterpretation.relationlinks+=newLink

-                                        

-                                        // Scope propagation

-                                        scopePropagator.propagateAdditionToType(typeInterpretation)

-                                        

-                                        statistics.addExecutionTime(System.nanoTime-startTime)

+

+                                        createObjectActionWithContainment(

+                                                nameNewElement,

+                                                interpretation,

+                                                typeInterpretation,

+                                                container,

+                                                relationInterpretation,

+                                                [createDefinedElement],

+                                                recursiveObjectCreations,

+                                                unitRulePropagator

+                                        )

+                                        statistics.addExecutionTime(System.nanoTime - startTime)

+

+                                        unitRulePropagator.propagate

                                 ]

                         }

                 } else {

-                        ruleBuilder.action[match |

+                        ruleBuilder.action [ match |

+                                statistics.incrementTransformationCount

+//                              println(name)

                                 val startTime = System.nanoTime

-                                //val problem = match.get(0) as LogicProblem

+                                // val problem = match.get(0) as LogicProblem

                                 val interpretation = match.get(1) as PartialInterpretation

                                 val typeInterpretation = match.get(2) as PartialComplexTypeInterpretation

-                                

-                                val newElement = createDefinedElement

-                                if(nameNewElement) {

-                                        newElement.name = '''new «interpretation.newElements.size»'''

-                                }

-                                

-                                // Existence

-                                interpretation.newElements+=newElement

-                                /*

-                                interpretation.maxNewElements=interpretation.maxNewElements-1

-                                if(interpretation.minNewElements > 0) {

-                                        interpretation.minNewElements=interpretation.minNewElements-1

-                                }*/

-                                

-                                // Types

-                                typeInterpretation.elements += newElement

-                                typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement]

-                                

-                                // Scope propagation

-                                scopePropagator.propagateAdditionToType(typeInterpretation)

-                                

-                                statistics.addExecutionTime(System.nanoTime-startTime)

+

+                                createObjectAction(

+                                        nameNewElement,

+                                        interpretation,

+                                        typeInterpretation,

+                                        [createDefinedElement],

+                                        recursiveObjectCreations,

+                                        unitRulePropagator

+                                )

+                                statistics.addExecutionTime(System.nanoTime - startTime)

+

+                                unitRulePropagator.propagate

                         ]

                 }

                 return ruleBuilder.build

         }

-        

-        def createRelationRefinementRules(GeneratedPatterns patterns, ModelGenerationStatistics statistics) {

+

+        def private recursiveObjectCreation(LogicProblem p, PartialInterpretation i) {

+                val Map<Type, List<ObjectCreationInterpretationData>> recursiveObjectCreation = new HashMap

+                for (type : p.types) {

+                        recursiveObjectCreation.put(type, new LinkedList)

+                }

+

+                val containmentReferences = p.containmentHierarchies.head.containmentRelations

+

+                for (relationInterpretation : i.partialrelationinterpretation) {

+                        val relation = relationInterpretation.interpretationOf

+                        val lowermultiplicities = p.annotations.filter(LowerMultiplicityAssertion).filter[it.relation === relation]

+                        if ((!lowermultiplicities.empty)) {

+                                val number = lowermultiplicities.head.lower

+                                if (number > 0) {

+                                        val sourceTypeInterpretation = getTypeInterpretation(i, relation,

+                                                0) as PartialComplexTypeInterpretation

+                                        val subtypeInterpretations = i.partialtypeinterpratation.filter(PartialComplexTypeInterpretation).

+                                                filter [

+                                                        it === sourceTypeInterpretation ||

+                                                                it.supertypeInterpretation.contains(sourceTypeInterpretation)

+                                                ]

+

+                                        if (containmentReferences.contains(relation)) {

+                                                val targetTypeInterpretation = getTypeInterpretation(i, relation, 1)

+                                                val targetType = (targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf

+                                                if ((!targetType.isIsAbstract) && (targetType.supertypes.empty)) {

+                                                        val inverseAnnotation = p.annotations.filter(InverseRelationAssertion).filter [

+                                                                it.inverseA === relation || it.inverseB === relation

+                                                        ]

+                                                        if (!inverseAnnotation.empty) {

+                                                                val onlyInverseAnnotation = if (inverseAnnotation.head.inverseA === relation) {

+                                                                                inverseAnnotation.head.inverseB

+                                                                        } else {

+                                                                                inverseAnnotation.head.inverseA

+                                                                        }

+                                                                val inverseRelationInterpretation = i.partialrelationinterpretation.filter [

+                                                                        it.interpretationOf === onlyInverseAnnotation

+                                                                ].head

+                                                                for (subTypeInterpretation : subtypeInterpretations) {

+                                                                        for (var times = 0; times < number; times++) {

+                                                                                recursiveObjectCreation.get(subTypeInterpretation.interpretationOf) +=

+                                                                                        new ObjectCreationInterpretationData(

+                                                                                                i,

+                                                                                                targetTypeInterpretation,

+                                                                                                relationInterpretation,

+                                                                                                inverseRelationInterpretation,

+                                                                                                targetTypeInterpretation.getTypeConstructor

+                                                                                        )

+                                                                        }

+                                                                }

+                                                        } else {

+                                                                for (subTypeInterpretation : subtypeInterpretations) {

+                                                                        for (var times = 0; times < number; times++) {

+                                                                                recursiveObjectCreation.get(subTypeInterpretation.interpretationOf) +=

+                                                                                        new ObjectCreationInterpretationData(

+                                                                                                i,

+                                                                                                targetTypeInterpretation,

+                                                                                                relationInterpretation,

+                                                                                                null,

+                                                                                                targetTypeInterpretation.getTypeConstructor

+                                                                                        )

+                                                                        }

+                                                                }

+                                                        }

+                                                }

+                                        } else if (relation.parameters.get(1) instanceof PrimitiveTypeReference) {

+                                                val targetTypeInterpretation = getTypeInterpretation(i, relation, 1)

+                                                for (subTypeInterpretation : subtypeInterpretations) {

+                                                        for (var times = 0; times < number; times++) {

+                                                                recursiveObjectCreation.get(subTypeInterpretation.interpretationOf) +=

+                                                                        new ObjectCreationInterpretationData(

+                                                                                i,

+                                                                                targetTypeInterpretation,

+                                                                                relationInterpretation,

+                                                                                null,

+                                                                                targetTypeInterpretation.getTypeConstructor

+                                                                        )

+                                                        }

+                                                }

+                                        }

+                                }

+                        }

+                }

+

+                // Doing the recursion

+                var objectCreations = new LinkedList(recursiveObjectCreation.values.flatten.toList)

+                for (objectCreation : objectCreations) {

+                        val newInterpretation = objectCreation.typeInterpretation

+                        if (newInterpretation instanceof PartialComplexTypeInterpretation) {

+                                val newlyCreatedType = newInterpretation.interpretationOf

+                                if (recursiveObjectCreation.containsKey(newlyCreatedType)) {

+                                        val actionsWhenTypeCreated = recursiveObjectCreation.get(newlyCreatedType)

+                                        objectCreation.recursiveConstructors += actionsWhenTypeCreated

+                                }

+                        }

+                }

+

+                // checking acyclicity

+                for (objectCreation : objectCreations) {

+                        var reachable = objectCreation.recursiveConstructors

+                        do {

+                                if (reachable.contains(objectCreation)) {

+                                        throw new IllegalArgumentException('''Cicrle in the containment!''')

+                                } else {

+                                        reachable = reachable.map[it.recursiveConstructors].flatten.toList

+                                }

+                        } while (!reachable.empty)

+                }

+

+                return recursiveObjectCreation

+        }

+

+        private def getTypeInterpretation(PartialInterpretation i, RelationDeclaration relation, int index) {

+                val typeReference = relation.parameters.get(index)

+                return getTypeInterpretation(i, typeReference)

+

+        }

+

+        private dispatch def getTypeInterpretation(PartialInterpretation i, ComplexTypeReference reference) {

+                return i.partialtypeinterpratation.filter(PartialComplexTypeInterpretation).filter [

+                        it.getInterpretationOf == reference.referred

+                ].head

+        }

+

+        private dispatch def getTypeInterpretation(PartialInterpretation i, BoolTypeReference reference) {

+                return i.partialtypeinterpratation.filter(PartialBooleanInterpretation).head

+        }

+

+        private dispatch def getTypeInterpretation(PartialInterpretation i, IntTypeReference reference) {

+                return i.partialtypeinterpratation.filter(PartialIntegerInterpretation).head

+        }

+

+        private dispatch def getTypeInterpretation(PartialInterpretation i, RealTypeReference reference) {

+                return i.partialtypeinterpratation.filter(PartialRealInterpretation).head

+        }

+

+        private dispatch def getTypeInterpretation(PartialInterpretation i, StringTypeReference reference) {

+                return i.partialtypeinterpratation.filter(PartialStringInterpretation).head

+        }

+

+        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialComplexTypeInterpretation reference) {

+                [createDefinedElement]

+        }

+

+        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialBooleanInterpretation reference) {

+                [createBooleanElement]

+        }

+

+        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialIntegerInterpretation reference) {

+                [createIntegerElement]

+        }

+

+        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialRealInterpretation reference) {

+                [createRealElement]

+        }

+

+        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialStringInterpretation reference) {

+                [createStringElement]

+        }

+

+        def createRelationRefinementRules(GeneratedPatterns patterns, UnitRulePropagator unitRulePropagator,

+                ModelGenerationStatistics statistics) {

                 val res = new LinkedHashMap

-                for(LHSEntry: patterns.refinerelationQueries.entrySet) {

+                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)

-                        res.put(LHSEntry.key,rule)

+                        val rule = createRelationRefinementRule(declaration, inverseReference, lhs, unitRulePropagator, 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)

-        {

-                val name = '''addRelation_«declaration.name.canonizeName»«IF inverseRelation != null»_and_«inverseRelation.name.canonizeName»«ENDIF»'''

-                val ruleBuilder = factory.createRule

-                        .name(name)

-                        .precondition(lhs)

-                if (inverseRelation == null) {

+

+        def private BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>> createRelationRefinementRule(

+                RelationDeclaration declaration, Relation inverseRelation,

+                IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, UnitRulePropagator unitRulePropagator,

+                ModelGenerationStatistics statistics) {

+                val name = '''addRelation_«declaration.name.canonizeName»«IF inverseRelation !== null»_and_«inverseRelation.name.canonizeName»«ENDIF»'''

+                val ruleBuilder = factory.createRule(lhs).name(name)

+                if (inverseRelation === null) {

                         ruleBuilder.action [ match |

-                            val startTime = System.nanoTime

-                                //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

-                                val link = createBinaryElementRelationLink => [it.param1 = src it.param2 = trg]

-                                relationInterpretation.relationlinks += link

-                statistics.addExecutionTime(System.nanoTime-startTime)

+                                statistics.incrementTransformationCount

+//                              println(name)

+                                val startTime = System.nanoTime

+                                createRelationLinkAction(match, unitRulePropagator)

+                                statistics.addExecutionTime(System.nanoTime - startTime)

+

+                                unitRulePropagator.propagate

                         ]

                 } else {

                         ruleBuilder.action [ match |

-                            val startTime = System.nanoTime

-                                //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

-                                val link = createBinaryElementRelationLink => [it.param1 = src it.param2 = trg]

-                                relationInterpretation.relationlinks += link

-                                val inverseLink = createBinaryElementRelationLink => [it.param1 = trg it.param2 = src]

-                                inverseInterpretation.relationlinks += inverseLink

-                                statistics.addExecutionTime(System.nanoTime-startTime)

+                                statistics.incrementTransformationCount

+//                              println(name)

+                                val startTime = System.nanoTime

+                                createRelationLinkWithInverse(match, unitRulePropagator)

+                                statistics.addExecutionTime(System.nanoTime - startTime)

+

+                                unitRulePropagator.propagate

                         ]

                 }

 

                 return ruleBuilder.build

         }

+

+        // ///////////////////////

+        // Actions

+        // ///////////////////////

+        protected def void createObjectAction(boolean nameNewElement, ObjectCreationInterpretationData data,

+                DefinedElement container, UnitRulePropagator unitRulePropagator) {

+                if (data.containerInterpretation !== null) {

+                        if (data.containerInverseInterpretation !== null) {

+                                createObjectActionWithContainmentAndInverse(

+                                        nameNewElement,

+                                        data.interpretation,

+                                        data.typeInterpretation,

+                                        container,

+                                        data.containerInterpretation,

+                                        data.containerInverseInterpretation,

+                                        data.constructor,

+                                        data.recursiveConstructors,

+                                        unitRulePropagator

+                                )

+                        } else {

+                                createObjectActionWithContainment(

+                                        nameNewElement,

+                                        data.interpretation,

+                                        data.typeInterpretation,

+                                        container,

+                                        data.containerInterpretation,

+                                        data.constructor,

+                                        data.recursiveConstructors,

+                                        unitRulePropagator

+                                )

+                        }

+                } else {

+                        createObjectAction(

+                                nameNewElement,

+                                data.interpretation,

+                                data.typeInterpretation,

+                                data.constructor,

+                                data.recursiveConstructors,

+                                unitRulePropagator

+                        )

+                }

+

+        }

+

+        protected def createObjectActionWithContainmentAndInverse(

+                boolean nameNewElement,

+                PartialInterpretation interpretation,

+                PartialTypeInterpratation typeInterpretation,

+                DefinedElement container,

+                PartialRelationInterpretation relationInterpretation,

+                PartialRelationInterpretation inverseRelationInterpretation,

+                Function0<DefinedElement> constructor,

+                List<ObjectCreationInterpretationData> recursiceObjectCreations,

+                UnitRulePropagator unitRulePropagator

+        ) {

+                val newElement = constructor.apply

+                if (nameNewElement) {

+                        newElement.name = '''new «interpretation.newElements.size»'''

+                }

+

+                // Types

+                typeInterpretation.elements += newElement

+                if (typeInterpretation instanceof PartialComplexTypeInterpretation) {

+                        typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement]

+                }

+                // ContainmentRelation

+                val newLink1 = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement]

+                relationInterpretation.relationlinks += newLink1

+                // Inverse Containment

+                val newLink2 = factory2.createBinaryElementRelationLink => [it.param1 = newElement it.param2 = container]

+                inverseRelationInterpretation.relationlinks += newLink2

+

+                // Scope propagation

+                unitRulePropagator.decrementTypeScope(typeInterpretation)

+                unitRulePropagator.addedToRelation(relationInterpretation.interpretationOf)

+                unitRulePropagator.addedToRelation(inverseRelationInterpretation.interpretationOf)

+

+                // Existence

+                interpretation.newElements += newElement

+

+                // Do recursive object creation

+                for (newConstructor : recursiceObjectCreations) {

+                        createObjectAction(nameNewElement, newConstructor, newElement, unitRulePropagator)

+                }

+

+                return newElement

+        }

+

+        protected def createObjectActionWithContainment(

+                boolean nameNewElement,

+                PartialInterpretation interpretation,

+                PartialTypeInterpratation typeInterpretation,

+                DefinedElement container,

+                PartialRelationInterpretation relationInterpretation,

+                Function0<DefinedElement> constructor,

+                List<ObjectCreationInterpretationData> recursiceObjectCreations,

+                UnitRulePropagator unitRulePropagator

+        ) {

+                val newElement = constructor.apply

+                if (nameNewElement) {

+                        newElement.name = '''new «interpretation.newElements.size»'''

+                }

+

+                // Types

+                typeInterpretation.elements += newElement

+                if (typeInterpretation instanceof PartialComplexTypeInterpretation) {

+                        typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement]

+                }

+                // ContainmentRelation

+                val newLink = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement]

+                relationInterpretation.relationlinks += newLink

+                unitRulePropagator.addedToRelation(relationInterpretation.interpretationOf)

+

+                // Scope propagation

+                unitRulePropagator.decrementTypeScope(typeInterpretation)

+

+                // Existence

+                interpretation.newElements += newElement

+

+                // Do recursive object creation

+                for (newConstructor : recursiceObjectCreations) {

+                        createObjectAction(nameNewElement, newConstructor, newElement, unitRulePropagator)

+                }

+

+                return newElement

+        }

+

+        protected def createObjectAction(boolean nameNewElement, PartialInterpretation interpretation,

+                PartialTypeInterpratation typeInterpretation, Function0<DefinedElement> constructor,

+                List<ObjectCreationInterpretationData> recursiceObjectCreations, UnitRulePropagator unitRulePropagator) {

+                val newElement = constructor.apply

+                if (nameNewElement) {

+                        newElement.name = '''new «interpretation.newElements.size»'''

+                }

+

+                // Types

+                typeInterpretation.elements += newElement

+                if (typeInterpretation instanceof PartialComplexTypeInterpretation) {

+                        typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement]

+                }

+

+                // Scope propagation

+                unitRulePropagator.decrementTypeScope(typeInterpretation)

+

+                // Existence

+                interpretation.newElements += newElement

+

+                // Do recursive object creation

+                for (newConstructor : recursiceObjectCreations) {

+                        createObjectAction(nameNewElement, newConstructor, newElement, unitRulePropagator)

+                }

+

+                return newElement

+        }

+

+        protected def createRelationLinkAction(IPatternMatch match, UnitRulePropagator unitRulePropagator) {

+                // 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, unitRulePropagator)

+        }

+

+        protected def void createRelationLinkAction(DefinedElement src, DefinedElement trg,

+                PartialRelationInterpretation relationInterpretation, UnitRulePropagator unitRulePropagator) {

+                val link = createBinaryElementRelationLink => [it.param1 = src it.param2 = trg]

+                relationInterpretation.relationlinks += link

+                unitRulePropagator.addedToRelation(relationInterpretation.interpretationOf)

+        }

+

+        protected def void createRelationLinkWithInverse(IPatternMatch match, UnitRulePropagator unitRulePropagator) {

+                // 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, unitRulePropagator)

+        }

+

+        protected def void createRelationLinkWithInverse(DefinedElement src, DefinedElement trg,

+                PartialRelationInterpretation relationInterpretation, PartialRelationInterpretation inverseInterpretation,

+                UnitRulePropagator unitRulePropagator) {

+                val link = createBinaryElementRelationLink => [it.param1 = src it.param2 = trg]

+                relationInterpretation.relationlinks += link

+                val inverseLink = createBinaryElementRelationLink => [it.param1 = trg it.param2 = src]

+                inverseInterpretation.relationlinks += inverseLink

+                unitRulePropagator.addedToRelation(relationInterpretation.interpretationOf)

+                unitRulePropagator.addedToRelation(inverseInterpretation.interpretationOf)

+        }

+

+        static class UnitRulePropagator {

+                val LogicProblem p

+                val PartialInterpretation i

+                val RefinementRuleProvider refinementRuleProvider

+                var AdvancedViatraQueryEngine queryEngine

+                var Field delayMessageDelivery

+                val ScopePropagator scopePropagator

+                val List<AbstractMustRelationPropagator<? extends IPatternMatch>> propagators

+                val ModelGenerationStatistics statistics

+

+                new(LogicProblem p, PartialInterpretation i, RefinementRuleProvider refinementRuleProvider,

+                        ScopePropagator scopePropagator,

+                        Map<Pair<RelationDeclaration, Relation>, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> mustRelationPropagationQueries,

+                        ModelGenerationStatistics statistics) {

+                        this.p = p

+                        this.i = i

+                        this.refinementRuleProvider = refinementRuleProvider

+                        queryEngine = ViatraQueryEngine.on(new EMFScope(i)) as AdvancedViatraQueryEngine

+                        delayMessageDelivery = queryEngine.class.getDeclaredField("delayMessageDelivery")

+                        delayMessageDelivery.accessible = true

+                        this.scopePropagator = scopePropagator

+                        propagators = ImmutableList.copyOf(mustRelationPropagationQueries.entrySet.map [ entry |

+                                val matcher = queryEngine.getMatcher(entry.value)

+                                getPropagator(entry.key.key, entry.key.value, matcher)

+                        ])

+                        this.statistics = statistics

+                }

+

+                def decrementTypeScope(PartialTypeInterpratation partialTypeInterpratation) {

+                        scopePropagator.decrementTypeScope(partialTypeInterpratation)

+                }

+

+                def addedToRelation(Relation r) {

+                        scopePropagator.addedToRelation(r)

+                }

+

+                def propagate() {

+                        var boolean changed

+                        do {

+                                val scopeChanged = propagateScope()

+                                val mustChanged = propagateMustRelations()

+                                changed = scopeChanged || mustChanged

+                        } while (changed)

+                }

+

+                protected def flushQueryEngine() {

+                        if (queryEngine.updatePropagationDelayed) {

+                                delayMessageDelivery.setBoolean(queryEngine, false)

+                                queryEngine.getQueryBackend(ReteBackendFactory.INSTANCE).flushUpdates

+                                delayMessageDelivery.setBoolean(queryEngine, true)

+                        }

+                }

+

+                protected def propagateScope() {

+                        if (scopePropagator.scopePropagationNeeded) {

+                                if (scopePropagator.queryEngineFlushRequiredBeforePropagation) {

+                                        flushQueryEngine()

+                                }

+                                val propagatorStartTime = System.nanoTime

+                                scopePropagator.propagateAllScopeConstraints()

+                                statistics.addScopePropagationTime(System.nanoTime - propagatorStartTime)

+                                true

+                        } else {

+                                false

+                        }

+                }

+

+                protected def propagateMustRelations() {

+                        if (propagators.empty) {

+                                return false

+                        }

+                        flushQueryEngine()

+                        val propagatorStartTime = System.nanoTime

+                        var changed = false

+                        for (propagator : propagators) {

+                                changed = propagator.propagate(p, i, refinementRuleProvider, this) || changed

+                        }

+                        statistics.addMustRelationPropagationTime(System.nanoTime - propagatorStartTime)

+                        changed

+                }

+

+                private static def <T extends IPatternMatch> getPropagator(Relation relation, Relation inverseRelation,

+                        ViatraQueryMatcher<T> matcher) {

+                        if (inverseRelation === null) {

+                                new MustRelationPropagator(matcher)

+                        } else if (relation == inverseRelation) {

+                                new MustRelationPropagatorWithSelfInverse(matcher)

+                        } else {

+                                new MustRelationPropagatorWithInverse(matcher)

+                        }

+                }

+

+                @FinalFieldsConstructor

+                private static abstract class AbstractMustRelationPropagator<T extends IPatternMatch> {

+                        val ViatraQueryMatcher<T> matcher

+

+                        def propagate(LogicProblem p, PartialInterpretation i, RefinementRuleProvider refinementRuleProvider,

+                                UnitRulePropagator unitRulePropagator) {

+                                val iterator = getIterator(p, i)

+                                if (!iterator.hasNext) {

+                                        return false

+                                }

+                                iterate(iterator, refinementRuleProvider, unitRulePropagator)

+                                true

+                        }

+

+                        def iterate(Iterator<T> iterator, RefinementRuleProvider refinementRuleProvider,

+                                UnitRulePropagator unitRulePropagator) {

+                                while (iterator.hasNext) {

+                                        doPropagate(iterator.next, refinementRuleProvider, unitRulePropagator)

+                                }

+                        }

+

+                        protected def getIterator(LogicProblem p, PartialInterpretation i) {

+                                val partialMatch = matcher.newEmptyMatch

+                                partialMatch.set(0, p)

+                                partialMatch.set(1, i)

+                                matcher.streamAllMatches(partialMatch).iterator

+                        }

+

+                        protected def void doPropagate(T match, RefinementRuleProvider refinementRuleProvider,

+                                UnitRulePropagator unitRulePropagator)

+                }

+

+                private static class MustRelationPropagator<T extends IPatternMatch> extends AbstractMustRelationPropagator<T> {

+                        new(ViatraQueryMatcher<T> matcher) {

+                                super(matcher)

+                        }

+

+                        override protected doPropagate(T match, RefinementRuleProvider refinementRuleProvider,

+                                UnitRulePropagator unitRulePropagator) {

+                                refinementRuleProvider.createRelationLinkAction(match, unitRulePropagator)

+                        }

+                }

+

+                private static class MustRelationPropagatorWithInverse<T extends IPatternMatch> extends AbstractMustRelationPropagator<T> {

+                        new(ViatraQueryMatcher<T> matcher) {

+                                super(matcher)

+                        }

+

+                        override protected doPropagate(T match, RefinementRuleProvider refinementRuleProvider,

+                                UnitRulePropagator unitRulePropagator) {

+                                refinementRuleProvider.createRelationLinkWithInverse(match, unitRulePropagator)

+                        }

+                }

+

+                private static class MustRelationPropagatorWithSelfInverse<T extends IPatternMatch> extends MustRelationPropagatorWithInverse<T> {

+                        new(ViatraQueryMatcher<T> matcher) {

+                                super(matcher)

+                        }

+

+                        override iterate(Iterator<T> iterator, RefinementRuleProvider refinementRuleProvider,

+                                UnitRulePropagator unitRulePropagator) {

+                                val pairs = newHashSet

+                                while (iterator.hasNext) {

+                                        val match = iterator.next

+                                        val src = match.get(4) as DefinedElement

+                                        val trg = match.get(5) as DefinedElement

+                                        if (!pairs.contains(trg -> src)) {

+                                                pairs.add(src -> trg)

+                                                doPropagate(match, refinementRuleProvider, unitRulePropagator)

+                                        }

+                                }

+                        }

+                }

+        }

+}

+

+@Data

+class ObjectCreationInterpretationData {

+        PartialInterpretation interpretation

+        PartialTypeInterpratation typeInterpretation

+        PartialRelationInterpretation containerInterpretation

+        PartialRelationInterpretation containerInverseInterpretation

+        Function0<DefinedElement> constructor

+        List<ObjectCreationInterpretationData> recursiveConstructors = new LinkedList

 }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/util/ParseUtil.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/util/ParseUtil.xtend
index 8e264488..26ec7091 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/util/ParseUtil.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/util/ParseUtil.xtend
@@ -196,8 +196,20 @@ class ParseUtil {
 }

 

 class FixedMetamodelProvider implements IMetamodelProvider {

+        

+        static val EPACKAGE_TO_PLUGIN_MAP = #{

+                PartialinterpretationPackage.eINSTANCE -> "hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage",

+                LogicproblemPackage.eINSTANCE -> "hu.bme.mit.inf.dslreasoner.logic.model",

+                LogiclanguagePackage.eINSTANCE -> "hu.bme.mit.inf.dslreasoner.logic.model"

+        }

+        

+        static val EPACKAGE_TO_JAVA_PACKAGE_MAP = #{

+                PartialinterpretationPackage.eINSTANCE -> "hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation",

+                LogicproblemPackage.eINSTANCE -> "hu.bme.mit.inf.dslreasoner.logic.model.logicproblem",

+                LogiclanguagePackage.eINSTANCE -> "hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage"

+        }

 

-        protected val List<EPackage> packages = new LinkedList

+        val List<EPackage> packages = new LinkedList

 

         new() {

                 packages += PartialinterpretationPackage.eINSTANCE

@@ -213,15 +225,24 @@ class FixedMetamodelProvider implements IMetamodelProvider {
         }

 

         override boolean isGeneratedCodeAvailable(EPackage ePackage, ResourceSet set) {

-                true

+                EPACKAGE_TO_PLUGIN_MAP.containsKey(ePackage)

         }

 

         override String getModelPluginId(EPackage ePackage, ResourceSet set) {

-                return "hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage"

+                EPACKAGE_TO_PLUGIN_MAP.get(ePackage)

         }

 

         override String getQualifiedClassName(EClassifier classifier, EObject context) {

-                classifier.name

+                val instanceClassName = classifier.instanceClassName

+                if (instanceClassName !== null) {

+                        return instanceClassName

+                }

+                val javaPackage = EPACKAGE_TO_JAVA_PACKAGE_MAP.get(classifier.EPackage)

+                if (javaPackage !== null) {

+                        javaPackage + "." + classifier.name

+                } else {

+                        null

+                }

         }

 

         override loadEPackage(String uri, ResourceSet resourceSet) {

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/META-INF/MANIFEST.MF b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/META-INF/MANIFEST.MF
index 83c90829..639a8a9c 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/META-INF/MANIFEST.MF
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/META-INF/MANIFEST.MF
@@ -28,7 +28,8 @@ Require-Bundle: org.eclipse.core.runtime,
  org.eclipse.xtend.lib.macro,

  org.eclipse.viatra.query.runtime;bundle-version="1.5.0",

  org.eclipse.viatra.dse;bundle-version="0.15.0",

- hu.bme.mit.inf.dslreasoner.ecore2logic;bundle-version="1.0.0"

+ hu.bme.mit.inf.dslreasoner.ecore2logic;bundle-version="1.0.0",

+ org.eclipse.collections;bundle-version="10.1.0"

 Bundle-ActivationPolicy: lazy

 Automatic-Module-Name: hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage

 

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.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend
index f7a1ce4f..20ff58f2 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend
@@ -2,19 +2,24 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage
 

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.TypeScopes

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.And

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolLiteral

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntLiteral

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguageFactory

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealLiteral

 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.StringLiteral

+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicValue

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition

 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem

 import hu.bme.mit.inf.dslreasoner.logic.model.patterns.SupertypeStar

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partial2logicannotations.PartialModelRelation2Assertion

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BooleanElement

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.IntegerElement

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.NaryRelationLink

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialBooleanInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialIntegerInterpretation

@@ -22,10 +27,10 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.par
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRealInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialStringInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationFactory

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.RealElement

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.StringElement

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.UnaryElementRelationLink

 import java.math.BigDecimal

 import java.util.HashMap

 import java.util.Map

@@ -35,13 +40,6 @@ import org.eclipse.viatra.query.runtime.emf.EMFScope
 import org.eclipse.xtend.lib.annotations.Data

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicValue

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.And

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolLiteral

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntLiteral

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealLiteral

-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.StringLiteral

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation

 

 @Data class Problem2PartialInterpretationTrace {

         Map<TypeDeclaration, PartialComplexTypeInterpretation> type2Interpretation

@@ -193,7 +191,7 @@ class PartialInterpretationInitialiser {
                 interpretation.minNewElements = minNewElements

                 interpretation.maxNewElements = maxNewElements

                 // elements from problem are included

-                if(maxNewElements>0) {

+                if(maxNewElements != 0) {

                         val newElements = createDefinedElement => [it.name = "New Objects"]

                         interpretation.openWorldElements += newElements 

                 }

@@ -212,12 +210,8 @@ class PartialInterpretationInitialiser {
         def private initialiseTypeScope(PartialTypeInterpratation interpretation, Integer min, Integer max) {

                 val res = createScope

                 res.targetTypeInterpretation = interpretation

-                if(min !== null) {

-                        res.minNewElements = min

-                }

-                if(max !== null) {

-                        res.maxNewElements = max

-                }

+                res.minNewElements = min ?: 0

+                res.maxNewElements = max ?: -1

                 return res

         }

         

@@ -233,7 +227,11 @@ class PartialInterpretationInitialiser {
         

         def private Map<RelationDeclaration, PartialRelationInterpretation> initRelations(PartialInterpretation interpretation, PrimitiveValueTrace trace) {

                 val Map<RelationDeclaration, PartialRelationInterpretation> relation2Interpretation = new HashMap

-                for(relation : interpretation.problem.relations.filter(RelationDeclaration)) {

+                val definedRelationDeclarations = interpretation.problem.relations.filter(RelationDefinition).map[defines]

+                val undefinedRelationDeclarations = interpretation.problem.relations.filter(RelationDeclaration).filter[

+                        declared | !definedRelationDeclarations.exists[defined | defined === declared]

+                ]

+                for(relation : undefinedRelationDeclarations) {

                         val partialInterpretation = relation.initialisePartialRelationInterpretation

                         interpretation.partialrelationinterpretation += partialInterpretation

                         relation2Interpretation.put(relation,partialInterpretation)

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend
index 41482b28..685a1f5a 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/Descriptor.xtend
@@ -4,10 +4,21 @@ import java.util.HashMap
 import java.util.Map

 import java.util.Set

 import org.eclipse.xtend.lib.annotations.Data

+import org.eclipse.xtend2.lib.StringConcatenationClient

 

 @Data abstract class AbstractNodeDescriptor {

-        long dataHash

-        

+        int dataHash

+

+        protected def StringConcatenationClient prettyPrint() {

+                '''(«dataHash»)[«class.simpleName»]'''

+        }

+

+        override toString() {

+                '''

+                        «prettyPrint»

+                '''

+        }

+

 //      @Pure

 //      @Override

 //      override public boolean equals(Object obj) {

@@ -24,34 +35,45 @@ import org.eclipse.xtend.lib.annotations.Data
 //      }

 }

 

-@Data class LocalNodeDescriptor extends AbstractNodeDescriptor{

+@Data class LocalNodeDescriptor extends AbstractNodeDescriptor {

         Set<String> types

         String id;

+

         new(String id, Set<String> types) {

-                super(calcualteDataHash(id,types))

+                super(calcualteDataHash(id, types))

                 this.types = types

                 this.id = id

         }

-        

+

         def private static calcualteDataHash(String id, Set<String> types) {

                 val int prime = 31;

                 var result = 0

-            if(id !== null)

-                        result = id.hashCode();

-                if(types !== null) { 

-                        result = prime * result + types.hashCode

-                }

-                return result

+                if (id !== null)

+                        result = id.hashCode();

+                if (types !== null) {

+                        result = prime * result + types.hashCode

+                }

+                return result

         }

-        

+

         override hashCode() {

-                return this.dataHash.hashCode

+                return this.dataHash

         }

-        

+

+        override equals(Object other) {

+                other.class == LocalNodeDescriptor && (other as AbstractNodeDescriptor).hashCode == hashCode

+        }

+

+        override protected prettyPrint() {

+                '''(«dataHash»)[«IF id !== null»id = "«id»"«IF types === null || !types.empty», «ENDIF»«ENDIF»«IF types === null»TYPES = null«ELSE»«FOR type : types SEPARATOR ", "»«type»«ENDFOR»«ENDIF»]'''

+        }

+

         override toString() {

-                return class.name + this.dataHash

+                '''

+                        «prettyPrint»

+                '''

         }

-        

+

 //      @Pure

 //      @Override

 //      override public boolean equals(Object obj) {

@@ -66,7 +88,6 @@ import org.eclipse.xtend.lib.annotations.Data
 //                      return false;

 //              return true;

 //      }

-        

 //      @Pure

 //      override public boolean equals(Object obj) {

 //              if (this === obj)

@@ -97,118 +118,91 @@ import org.eclipse.xtend.lib.annotations.Data
         String type

 }

 

-@Data class FurtherNodeDescriptor<NodeRep> extends AbstractNodeDescriptor{

-        

-         NodeRep previousRepresentation

-         Map<IncomingRelation<NodeRep>,Integer> incomingEdges

-         Map<OutgoingRelation<NodeRep>,Integer> outgoingEdges

-         

-         new(

-                NodeRep previousRepresentation,

-                Map<IncomingRelation<NodeRep>,Integer> incomingEdges,

-                Map<OutgoingRelation<NodeRep>,Integer> outgoingEdges)

-        {

-                super(calculateDataHash(previousRepresentation,incomingEdges,outgoingEdges))

-                this.previousRepresentation = previousRepresentation

-                this.incomingEdges = new HashMap(incomingEdges)

-                this.outgoingEdges = new HashMap(outgoingEdges)

-         }

-         

-        static def private <NodeRep> int calculateDataHash(

-                NodeRep previousRepresentation,

-                Map<IncomingRelation<NodeRep>,Integer> incomingEdges,

-                Map<OutgoingRelation<NodeRep>,Integer> outgoingEdges)

-        {

-            val int prime = 31;

-            var int result = previousRepresentation.hashCode;

-            if(incomingEdges !== null)

-                        result = prime * result + incomingEdges.hashCode();

-                if(outgoingEdges !== null) 

-                        result = prime * result + outgoingEdges.hashCode();

-            return result;

-        }

-        

-        override hashCode() {

-                return this.dataHash.hashCode 

+@Data class FurtherNodeDescriptor<NodeRep> extends AbstractNodeDescriptor {

+        NodeRep previousRepresentation

+        Map<IncomingRelation<NodeRep>, Integer> incomingEdges

+        Map<OutgoingRelation<NodeRep>, Integer> outgoingEdges

+

+        new(NodeRep previousRepresentation, Map<IncomingRelation<NodeRep>, Integer> incomingEdges,

+                Map<OutgoingRelation<NodeRep>, Integer> outgoingEdges) {

+                super(calculateDataHash(previousRepresentation, incomingEdges, outgoingEdges))

+                this.previousRepresentation = previousRepresentation

+                this.incomingEdges = incomingEdges

+                this.outgoingEdges = outgoingEdges

         }

-        

-        override toString() {

-                return class.name + dataHash

-//              return '''[«previousRepresentation»,(«FOR

-//                      in: incomingEdges.entrySet»(«in.key.type.name»=«in.key.from»,«in.value»)«ENDFOR»),(«FOR

-//                      out: outgoingEdges.entrySet»(«out.key.type.name»=«out.key.to»,«out.value»)«ENDFOR»),«FOR

-//                      att: attributeValues»(«att.type.name»=«att.value»)«ENDFOR»]'''

+

+        static def private <NodeRep> int calculateDataHash(NodeRep previousRepresentation,

+                Map<IncomingRelation<NodeRep>, Integer> incomingEdges, Map<OutgoingRelation<NodeRep>, Integer> outgoingEdges) {

+                val int prime = 31;

+                var int result = previousRepresentation.hashCode;

+                if (incomingEdges !== null)

+                        result = prime * result + hashIncomingNeighborhood(incomingEdges)

+                if (outgoingEdges !== null)

+                        result = prime * result + hashOutgoingNeighborhood(outgoingEdges)

+                return result;

         }

-        

-//      @Pure

-//      @Override

-//      override public boolean equals(Object obj) {

-//              if (this === obj)

-//                      return true;

-//              if (obj === null)

-//                      return false;

-//              if (getClass() != obj.getClass())

-//                      return false;

-//              val AbstractNodeDescriptor other = obj as AbstractNodeDescriptor;

-//              if (other.dataHash != this.dataHash)

-//                      return false;

-//              return true;

-//      }

-        

-//      @Pure

-//      override public boolean equals(Object obj) {

-//              if (this === obj)

-//                      return true;

-//              if (obj === null)

-//                      return false;

-//              if (getClass() != obj.getClass())

-//                      return false;

-//              if (!super.equals(obj))

-//                      return false;

-//              val FurtherNodeDescriptor<?> other = obj as FurtherNodeDescriptor<?>;

-//              if (this.previousRepresentation === null) {

-//                      if (other.previousRepresentation != null)

-//                              return false;

-//                      

-//              }

-////            } else if (!this.previousRepresentation.equals(other.previousRepresentation))

-////                    return false;

-//              if (this.incomingEdges === null) {

-//                      if (other.incomingEdges != null)

-//                              return false;

-//              } else if (!this.incomingEdges.equals(other.incomingEdges))

-//                      return false;

-//              if (this.outgoingEdges === null) {

-//                      if (other.outgoingEdges != null)

-//                              return false;

-//              } else if (!this.outgoingEdges.equals(other.outgoingEdges))

-//                      return false;

-//              if (this.attributeValues === null) {

-//                      if (other.attributeValues != null)

-//                              return false;

-//              } else if (!this.attributeValues.equals(other.attributeValues))

-//                      return false;

-//              return true;

-//      }

-}

 

-/*

-@Data

-class ModelDescriptor {

-        int dataHash

-        int unknownElements

-        Map<? extends AbstractNodeDescriptor,Integer> knownElements

+        override hashCode() {

+                return this.dataHash

+        }

+

+        override equals(Object other) {

+                other.class == FurtherNodeDescriptor && (other as AbstractNodeDescriptor).hashCode == hashCode

+        }

+

+        override prettyPrint() {

+                '''

+                («dataHash»)[

+                        PREV = «previousRepresentation?.prettyPrint»

+                        «IF incomingEdges === null»

+                                IN null

+                        «ELSE»

+                                «FOR edge : incomingEdges.entrySet»

+                                        IN «edge.value» «edge.key.type» = «edge.key.from.prettyPrint»

+                                «ENDFOR»

+                        «ENDIF»

+                        «IF outgoingEdges === null»

+                                OUT null

+                        «ELSE»

+                                «FOR edge : outgoingEdges.entrySet»

+                                        OUT «edge.value» «edge.key.type» = «edge.key.to.prettyPrint»

+                                «ENDFOR»

+                        «ENDIF»

+                ]'''

+        }

+

+        private def StringConcatenationClient prettyPrint(NodeRep rep) {

+                if (rep instanceof AbstractNodeDescriptor) {

+                        rep.prettyPrint

+                } else {

+                        '''«rep»'''

+                }

+        }

         

-        public new(Map<? extends AbstractNodeDescriptor,Integer> knownElements, int unknownElements) {

-                this.dataHash = calculateDataHash(knownElements,unknownElements)

-                this.unknownElements = unknownElements

-                this.knownElements = knownElements

+        private static def <NodeRep> hashIncomingNeighborhood(Map<IncomingRelation<NodeRep>, Integer> neighborhood) {

+                val int prime = 31

+                var int hash = 0

+                for (entry : neighborhood.entrySet) {

+                        val relation = entry.key

+                        hash += (prime * relation.from.hashCode + relation.type.hashCode).bitwiseXor(entry.value.hashCode)

+                }

+                hash

         }

         

-        def private static calculateDataHash(Map<? extends AbstractNodeDescriptor,Integer> knownElements, int unknownElements)

-        {

-                val int prime = 31;

-                return knownElements.hashCode * prime + unknownElements.hashCode 

+        private static def <NodeRep> hashOutgoingNeighborhood(Map<OutgoingRelation<NodeRep>, Integer> neighborhood) {

+                val int prime = 31

+                var int hash = 0

+                for (entry : neighborhood.entrySet) {

+                        val relation = entry.key

+                        hash += (prime * relation.to.hashCode + relation.type.hashCode).bitwiseXor(entry.value.hashCode)

+                }

+                hash

+        }

+

+        override toString() {

+                '''

+                        «prettyPrint»

+                '''

         }

 }

-*/
\ No newline at end of file
+

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/NeighbourhoodOptions.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/NeighbourhoodOptions.xtend
new file mode 100644
index 00000000..c6e03f75
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/NeighbourhoodOptions.xtend
@@ -0,0 +1,22 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood
+
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
+import java.util.Set
+import org.eclipse.xtend.lib.annotations.Data
+
+@Data
+class NeighbourhoodOptions {
+        public static val FixPointRange = -1
+        public static val GraphWidthRange = -2
+        public static val FullParallels = Integer.MAX_VALUE
+        public static val MaxNumbers = Integer.MAX_VALUE
+
+        public static val DEFAULT = new NeighbourhoodOptions(FixPointRange, FullParallels, MaxNumbers, null, null)
+
+        val int range
+        val int parallels
+        val int maxNumber
+        val Set<TypeDeclaration> relevantTypes
+        val Set<RelationDeclaration> relevantRelations
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2Hash.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2Hash.xtend
index d474877d..5da202eb 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2Hash.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2Hash.xtend
@@ -1,25 +1,33 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood

 

-import java.util.Map

 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement

+import java.util.Map

+import org.eclipse.collections.api.factory.Maps

 

 class PartialInterpretation2Hash extends PartialInterpretation2NeighbourhoodRepresentation<Integer, Integer>{

         

-        protected new() {

+        new() {

                 super(false, true)

         }

         

         override protected createLocalRepresentation(Map<DefinedElement, LocalNodeDescriptor> node2Representation, Map<LocalNodeDescriptor, Integer> representation2Amount) {

                 return new NeighbourhoodWithTraces(

-                        representation2Amount.hashCode,node2Representation.mapValues[it.hashCode],

+                        representation2Amount.hashCode,node2Representation.hashValues,

                         null)

         }

         

         override protected createFurtherRepresentation(Map<FurtherNodeDescriptor<Integer>, Integer> nodeDescriptors, Map<DefinedElement, FurtherNodeDescriptor<Integer>> node2Representation, NeighbourhoodWithTraces<Integer, Integer> previous, boolean deepRepresentation) {

                 return new NeighbourhoodWithTraces(

                         nodeDescriptors.hashCode,

-                        node2Representation.mapValues[it.hashCode],

+                        node2Representation.hashValues,

                         if(deepRepresentation) {previous} else {null})

         }

         

+        private def <T> hashValues(Map<DefinedElement, T> map) {

+                val hashedMap = Maps.mutable.ofInitialCapacity(map.size)

+                for (entry : map.entrySet) {

+                        hashedMap.put(entry.key, entry.value.hashCode)

+                }

+                hashedMap

+        }

 }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend
index 6dc40705..93eab816 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2NeighbourhoodRepresentation.xtend
@@ -4,32 +4,34 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement
 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.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

-import java.util.HashMap

-import java.util.HashSet

-import java.util.LinkedList

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation

+import java.util.ArrayList

 import java.util.List

 import java.util.Map

 import java.util.Set

+import org.eclipse.collections.api.factory.Maps

+import org.eclipse.collections.impl.factory.Sets

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

 

-abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresentation,NodeRepresentation> {

-        private val boolean deepRepresentation

-        private val boolean mergeSimilarNeighbourhood

+abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresentation, NodeRepresentation> {

+        val boolean deepRepresentation

+        val boolean mergeSimilarNeighbourhood

 

         protected new(boolean deeprepresentation, boolean mergeSimilarNeighbourhood) {

                 this.deepRepresentation = deeprepresentation

                 this.mergeSimilarNeighbourhood = mergeSimilarNeighbourhood

         }

-        

-        public static val FixPointRage = -1

-        public static val GraphWidthRange = -2

-        public static val FullParallels = Integer.MAX_VALUE

-        public static val MaxNumbers = Integer.MAX_VALUE

-        

+

+        public static val FixPointRange = NeighbourhoodOptions.FixPointRange

+        public static val GraphWidthRange = NeighbourhoodOptions.GraphWidthRange

+        public static val FullParallels = NeighbourhoodOptions.FullParallels

+        public static val MaxNumbers = NeighbourhoodOptions.MaxNumbers

+

+        static val FOCUSED_ELEMENT_NAME = "<<THIS>>"

+

         /**

          * Creates a neighbourhood representation with traces

          * @param model The model to be represented.

@@ -37,10 +39,15 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
          * @param parallels The maximal number of parallel references to be differentiated.

          * @param maxNumber The maximal number of elements in a equivalence class that chan be differentiated.

          */

-        def public createRepresentation(PartialInterpretation model, int range, int parallels, int maxNumber) {

-                return createRepresentation(model,range,parallels,maxNumber,null,null)

+        def createRepresentation(PartialInterpretation model, int range, int parallels, int maxNumber) {

+                return createRepresentation(model, range, parallels, maxNumber, null, null)

+        }

+

+        def createRepresentation(PartialInterpretation model, NeighbourhoodOptions options) {

+                createRepresentation(model, options.range, options.parallels, options.maxNumber, options.relevantTypes,

+                        options.relevantRelations)

         }

-        

+

         /**

          * Creates a neighbourhood representation with traces

          * @param model The model to be represented.

@@ -48,72 +55,87 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
          * @param parallels The maximal number of parallel references to be differentiated.

          * @param maxNumber The maximal number of elements in a equivalence class that chan be differentiated.

          */

-        def public createRepresentation(

-                PartialInterpretation model,

-                int range, int parallels, int maxNumber,

-                Set<TypeDeclaration> relevantTypes, Set<RelationDeclaration> relevantRelations) 

-        {

-                val Map<DefinedElement, Set<String>> types = new HashMap

-                fillTypes(model,types,relevantTypes)

-                val Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations = new HashMap;

-                val Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations = new HashMap;

-                fillReferences(model,IncomingRelations,OutgoingRelations,relevantRelations)

-                

-                val res = doRecursiveNeighbourCalculation(model,types,IncomingRelations,OutgoingRelations,range,parallels,maxNumber);

-                

+        def createRepresentation(PartialInterpretation model, int range, int parallels, int maxNumber,

+                Set<TypeDeclaration> relevantTypes, Set<RelationDeclaration> relevantRelations) {

+                createRepresentationWithFocus(model, range, parallels, maxNumber, relevantTypes, relevantRelations, null)

+        }

+

+        def createRepresentationWithFocus(PartialInterpretation model, NeighbourhoodOptions options,

+                DefinedElement focusedElement) {

+                createRepresentationWithFocus(model, options.range, options.parallels, options.maxNumber, options.relevantTypes,

+                        options.relevantRelations, focusedElement)

+        }

+

+        def createRepresentationWithFocus(PartialInterpretation model, int range, int parallels, int maxNumber,

+                Set<TypeDeclaration> relevantTypes, Set<RelationDeclaration> relevantRelations, DefinedElement focusedElement) {

+                val initialSize = model.elements.size

+                val Map<DefinedElement, Set<String>> types = Maps.mutable.ofInitialCapacity(initialSize)

+                fillTypes(model, types, relevantTypes)

+                val Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations = Maps.mutable.ofInitialCapacity(initialSize);

+                val Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations = Maps.mutable.ofInitialCapacity(initialSize);

+                fillReferences(model, IncomingRelations, OutgoingRelations, relevantRelations)

+

+                val res = doRecursiveNeighbourCalculation(model, types, IncomingRelations, OutgoingRelations, range, parallels,

+                        maxNumber, focusedElement);

+

                 return res;

         }

-        

+

         def private isRelevant(TypeDeclaration t, Set<TypeDeclaration> relevantTypes) {

-                if(relevantTypes === null) {

+                if (relevantTypes === null) {

                         return true

                 } else {

                         return relevantTypes.contains(t)

                 }

         }

+

         def private isRelevant(RelationDeclaration r, Set<RelationDeclaration> relevantRelations) {

-                if(relevantRelations === null) {

+                if (relevantRelations === null) {

                         return true

                 } else {

                         return relevantRelations.contains(r)

                 }

         }

+

         /**

-         * Gets the largest 

+         * Gets the minimal neighbourhood size such that every reachable node appears in the shape of every other at least once.

          */

         def private getWidth(Map<DefinedElement, Set<String>> types,

                 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,

-                Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations)

-        {

-                val elements =  types.keySet

-                val Map<DefinedElement,Set<DefinedElement>> reachable = new HashMap

-                for(element : elements) {

-                        val set = new HashSet

+                Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations) {

+                val elements = types.keySet

+                var Map<DefinedElement, Set<DefinedElement>> reachable = Maps.mutable.ofInitialCapacity(elements.size)

+                var Map<DefinedElement, Set<DefinedElement>> newReachable = Maps.mutable.ofInitialCapacity(elements.size)

+                for (element : elements) {

+                        val set = Sets.mutable.of

                         set.add(element)

-                        reachable.put(element,set)

+                        reachable.put(element, Sets.mutable.of)

+                        newReachable.put(element, set)

                 }

-                

+

                 var int width = 0

                 var boolean newAdded

                 do {

+                        var tmp = reachable

+                        reachable = newReachable

+                        newReachable = tmp

                         newAdded = false

-                        for(element : elements) {

+                        for (element : elements) {

                                 val elementNeigbours = element.lookup(reachable)

-                                val size = elementNeigbours.size

-                                for(incoming : element.lookup(IncomingRelations)) {

-                                        elementNeigbours.addAll(incoming.from.lookup(reachable))

+                                val newElementNeigbours = element.lookup(newReachable)

+                                newElementNeigbours.addAll(elementNeigbours)

+                                for (incoming : element.lookup(IncomingRelations)) {

+                                        newElementNeigbours.addAll(incoming.from.lookup(reachable))

                                 }

-                                for(outgoing : element.lookup(OutgoingRelations)) {

-                                        elementNeigbours.addAll(outgoing.to.lookup(reachable))

+                                for (outgoing : element.lookup(OutgoingRelations)) {

+                                        newElementNeigbours.addAll(outgoing.to.lookup(reachable))

                                 }

-                                newAdded = newAdded || (elementNeigbours.size > size)

+                                newAdded = newAdded || (newElementNeigbours.size > elementNeigbours.size)

                         }

-                        

-                        width +=1

-                } while(newAdded)

+                        width += 1

+                } while (newAdded)

                 return width

         }

-        

         /**

          * Creates a neighbourhood representation with traces

          * @param model The model to be represented.

@@ -122,68 +144,71 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
          * @param range The range of the neighbourhood.

          * @param parallels The maximal number of parallel references to be differentiated.

          */

-        def private NeighbourhoodWithTraces<ModelRepresentation,NodeRepresentation> doRecursiveNeighbourCalculation(

-                PartialInterpretation model,

-                Map<DefinedElement, Set<String>> types,

+        def private NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> doRecursiveNeighbourCalculation(

+                PartialInterpretation model, Map<DefinedElement, Set<String>> types,

                 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,

-                Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations,

-                int range, int parallels, int maxNumber)

-        {

-                if(range == 0){

-                        val r = calculateLocalNodeDescriptors(model,types,maxNumber)

-                        val res = this.createLocalRepresentation(r.value,r.key)

-                        if(res.modelRepresentation === null) {

+                Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations, int range, int parallels,

+                int maxNumber, DefinedElement focusedElement) {

+                if (range == 0) {

+                        val r = calculateLocalNodeDescriptors(model, types, maxNumber, focusedElement)

+                        val res = this.createLocalRepresentation(r.value, r.key)

+                        if (res.modelRepresentation === null) {

                                 throw new IllegalArgumentException('''Model representation is null''')

-                        } else if(res.nodeRepresentations === null || res.nodeRepresentations.empty) {

+                        } else if (res.nodeRepresentations === null || res.nodeRepresentations.empty) {

                                 throw new IllegalArgumentException('''No node representation''')

-                        } else if(res.previousRepresentation !== null) {

+                        } else if (res.previousRepresentation !== null) {

                                 throw new IllegalArgumentException('''The previous representation of the first neighbourhood have to be null''')

-                        } else return res

-                } else if(range > 0) {

-                        val previous = doRecursiveNeighbourCalculation(model,types,IncomingRelations,OutgoingRelations,range-1,parallels,maxNumber)

-                        val r = calculateFurtherNodeDescriptors(model,previous,IncomingRelations,OutgoingRelations,parallels,maxNumber)

-                        //println('''Level «range» finished.''')

-                        val res = createFurtherRepresentation(r.key,r.value,previous,deepRepresentation)

-                        if(res.modelRepresentation === null) {

+                        } else

+                                return res

+                } else if (range > 0) {

+                        val previous = doRecursiveNeighbourCalculation(model, types, IncomingRelations, OutgoingRelations,

+                                range - 1, parallels, maxNumber, focusedElement)

+                        val r = calculateFurtherNodeDescriptors(model, previous, IncomingRelations, OutgoingRelations, parallels,

+                                maxNumber)

+                        // println('''Level «range» finished.''')

+                        val res = createFurtherRepresentation(r.key, r.value, previous, deepRepresentation)

+                        if (res.modelRepresentation === null) {

                                 throw new IllegalArgumentException('''Model representation is null''')

-                        } else if(res.nodeRepresentations === null || res.nodeRepresentations.empty) {

+                        } else if (res.nodeRepresentations === null || res.nodeRepresentations.empty) {

                                 throw new IllegalArgumentException('''No node representation''')

-                        } else if(res.previousRepresentation === null && deepRepresentation) {

+                        } else if (res.previousRepresentation === null && deepRepresentation) {

                                 throw new IllegalArgumentException('''Need previous representations''')

-                        } else return res

-                } else if (range == FixPointRage) {

-                        return refineUntilFixpoint(model,types,IncomingRelations,OutgoingRelations,parallels,maxNumber)

+                        } else

+                                return res

+                } else if (range == FixPointRange) {

+                        return refineUntilFixpoint(model, types, IncomingRelations, OutgoingRelations, parallels, maxNumber,

+                                focusedElement)

                 } else if (range == GraphWidthRange) {

-                        val width = this.getWidth(types,IncomingRelations,OutgoingRelations)

-                        //println(width)

-                        return doRecursiveNeighbourCalculation(model,types,IncomingRelations,OutgoingRelations,width,parallels,maxNumber)

+                        val width = this.getWidth(types, IncomingRelations, OutgoingRelations)

+                        // println(width)

+                        return doRecursiveNeighbourCalculation(model, types, IncomingRelations, OutgoingRelations, width, parallels,

+                                maxNumber, focusedElement)

                 }

         }

-        

-        def private refineUntilFixpoint(

-                PartialInterpretation model,

-                Map<DefinedElement, Set<String>> types,

+

+        def private refineUntilFixpoint(PartialInterpretation model, Map<DefinedElement, Set<String>> types,

                 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,

-                Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations,

-                int parallels, int maxNumbers)

-        {

+                Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations, int parallels, int maxNumbers,

+                DefinedElement focusedElement) {

                 var lastRange = 0

-                val last = calculateLocalNodeDescriptors(model,types,maxNumbers)

-                var lastRepresentation = this.createLocalRepresentation(last.value,last.key)

-                //println('''Level 0 finished.''')

+                val last = calculateLocalNodeDescriptors(model, types, maxNumbers, focusedElement)

+                var lastRepresentation = this.createLocalRepresentation(last.value, last.key)

+                // println('''Level 0 finished.''')

                 var boolean hasRefined

                 do {

-                        val nextRange = lastRange+1

-                        val next = calculateFurtherNodeDescriptors(model,lastRepresentation,IncomingRelations,OutgoingRelations,parallels,maxNumbers)

-                        val nextRepresentation = createFurtherRepresentation(next.key,next.value,lastRepresentation,deepRepresentation)

-                        

-                        val previousNumberOfTypes =lastRepresentation.nodeRepresentations.values.toSet.size

-                        val nextNumberOfTypes = nextRepresentation.nodeRepresentations.values.toSet.size

-                        hasRefined =  nextNumberOfTypes > previousNumberOfTypes

-                        

+                        val nextRange = lastRange + 1

+                        val next = calculateFurtherNodeDescriptors(model, lastRepresentation, IncomingRelations, OutgoingRelations,

+                                parallels, maxNumbers)

+                        val nextRepresentation = createFurtherRepresentation(next.key, next.value, lastRepresentation,

+                                deepRepresentation)

+

+                        val previousNumberOfTypes = Sets.immutable.withAll(lastRepresentation.nodeRepresentations.values).size

+                        val nextNumberOfTypes = Sets.immutable.withAll(nextRepresentation.nodeRepresentations.values).size

+                        hasRefined = nextNumberOfTypes > previousNumberOfTypes

+

                         lastRange = nextRange

                         lastRepresentation = nextRepresentation

-                        

+

 //                      if(hasRefined) {

 //                              println('''Level «nextRange» is calculated, number of types is refined: «previousNumberOfTypes» -> «nextNumberOfTypes»''')

 //                      } else {

@@ -192,211 +217,217 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                 } while (hasRefined)

                 return lastRepresentation

         }

-        

+

         def private getElements(PartialInterpretation model) {

-                return

-                        model.problem.elements +

-                        model.newElements +

-                        model.openWorldElements

+                return model.problem.elements + model.newElements + model.openWorldElements

         }

-        

-        def private fillTypes(PartialInterpretation model, Map<DefinedElement, Set<String>> node2Type, Set<TypeDeclaration> relevantTypes) {

-                for(element : model.elements) {

-                        node2Type.put(element, new HashSet)

+

+        def private fillTypes(PartialInterpretation model, Map<DefinedElement, Set<String>> node2Type,

+                Set<TypeDeclaration> relevantTypes) {

+                for (element : model.elements) {

+                        node2Type.put(element, Sets.mutable.of)

                 }

-                

+

 //              for(typeDefinition : model.problem.types.filter(TypeDefinition)) {

 //                      // Dont need

 //              }

-                for(typeInterpretation : model.partialtypeinterpratation) {

-                        if(typeInterpretation instanceof PartialPrimitiveInterpretation) {

-                                

-                        } else if(typeInterpretation instanceof PartialComplexTypeInterpretation) {

+                for (typeInterpretation : model.partialtypeinterpratation) {

+                        if (typeInterpretation instanceof PartialPrimitiveInterpretation) {

+                        } else if (typeInterpretation instanceof PartialComplexTypeInterpretation) {

                                 val type = typeInterpretation.interpretationOf

-                                if(type.isRelevant(relevantTypes)) {

-                                        for(element : typeInterpretation.elements) {

+                                if (type.isRelevant(relevantTypes)) {

+                                        for (element : typeInterpretation.elements) {

                                                 element.lookup(node2Type).add(type.name)

                                         }

                                 }

                         }

                 }

         }

-        

+

         /**

          * Indexes the references

          */

         def private fillReferences(PartialInterpretation model,

                 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,

                 Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations,

-                Set<RelationDeclaration> relevantRelations)

-        {

-                for(object : model.elements) {

-                        IncomingRelations.put(object,new LinkedList)

-                        OutgoingRelations.put(object,new LinkedList)

+                Set<RelationDeclaration> relevantRelations) {

+                for (object : model.elements) {

+                        IncomingRelations.put(object, new ArrayList)

+                        OutgoingRelations.put(object, new ArrayList)

                 }

-                for(relationInterpretation : model.partialrelationinterpretation) {

+                for (relationInterpretation : model.partialrelationinterpretation) {

                         val type = relationInterpretation.interpretationOf

-                        if(type.isRelevant(relevantRelations)) {

-                                for(link : relationInterpretation.relationlinks) {

-                                        if(link instanceof BinaryElementRelationLink) {

-                                                        OutgoingRelations.get(link.param1) += new OutgoingRelation(link.param2,type.name)

-                                                        IncomingRelations.get(link.param2) += new IncomingRelation(link.param1,type.name)

-                                        } else throw new UnsupportedOperationException

+                        if (type.isRelevant(relevantRelations)) {

+                                for (link : relationInterpretation.relationlinks) {

+                                        if (link instanceof BinaryElementRelationLink) {

+                                                OutgoingRelations.get(link.param1) += new OutgoingRelation(link.param2, type.name)

+                                                IncomingRelations.get(link.param2) += new IncomingRelation(link.param1, type.name)

+                                        } else

+                                                throw new UnsupportedOperationException

                                 }

                         }

                 }

         }

-        

+

         /**

          * Creates a local representation of the objects (aka zero range neighbourhood)

          */

-        def abstract protected NeighbourhoodWithTraces<ModelRepresentation,NodeRepresentation> createLocalRepresentation(

+        def abstract protected NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> createLocalRepresentation(

                 Map<DefinedElement, LocalNodeDescriptor> node2Representation,

                 Map<LocalNodeDescriptor, Integer> representation2Amount

         )

-        

+

         /**

          * Creates a 

          */

-        def abstract protected NeighbourhoodWithTraces<ModelRepresentation,NodeRepresentation> createFurtherRepresentation(

+        def abstract protected NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> createFurtherRepresentation(

                 Map<FurtherNodeDescriptor<NodeRepresentation>, Integer> nodeDescriptors,

                 Map<DefinedElement, FurtherNodeDescriptor<NodeRepresentation>> node2Representation,

-                NeighbourhoodWithTraces<ModelRepresentation,NodeRepresentation> previous,

+                NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> previous,

                 boolean deepRepresentation

         )

-        

-        def private addOne(int original, int max) {

+

+        def private addOne(Integer originalObj, int max) {

+                if (originalObj === null) {

+                        return 1

+                }

+                val original = originalObj.intValue

                 if(original == Integer.MAX_VALUE) return Integer.MAX_VALUE

-                if(original +1 > max) return Integer.MAX_VALUE

-                else return original+1

+                if(original + 1 > max) return Integer.MAX_VALUE else return original + 1

         }

-        

+

         private def calculateIncomingEdges(Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,

-                DefinedElement object, Map<DefinedElement, ? extends NodeRepresentation> previousNodeRepresentations, int parallel)

-        {               

-                val Map<IncomingRelation<NodeRepresentation>, Integer> res = new HashMap

+                DefinedElement object, Map<DefinedElement, ? extends NodeRepresentation> previousNodeRepresentations,

+                int parallel) {

+                val Map<IncomingRelation<NodeRepresentation>, Integer> res = Maps.mutable.of

                 for (incomingConcreteEdge : IncomingRelations.get(object)) {

                         val IncomingRelation<NodeRepresentation> e = new IncomingRelation(

                                 previousNodeRepresentations.get(incomingConcreteEdge.from), incomingConcreteEdge.type)

-                        if (res.containsKey(e)) {

-                                res.put(e, addOne(res.get(e),parallel))

-                        } else {

-                                res.put(e, 1)

-                        }

+                        res.compute(e, [key, value | addOne(value, parallel)])

                 }

                 return res

         }

-        

-        private def calcuateOutgoingEdges(Map<DefinedElement,List<OutgoingRelation<DefinedElement>>> OutgoingRelations,

-                DefinedElement object, Map<DefinedElement, ? extends NodeRepresentation> previousNodeRepresentations, int parallel)

-        {

-                val Map<OutgoingRelation<NodeRepresentation>,Integer> res= new HashMap

-                for(outgoingConcreteEdge : OutgoingRelations.get(object)) {

-                        val OutgoingRelation<NodeRepresentation> e =

-                                new OutgoingRelation(

-                                        previousNodeRepresentations.get(outgoingConcreteEdge.to),

-                                        outgoingConcreteEdge.type)

-                        if(res.containsKey(e)) {

-                                res.put(e,addOne(res.get(e),parallel))

-                        } else {

-                                res.put(e,1)

-                        }

+

+        private def calcuateOutgoingEdges(Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations,

+                DefinedElement object, Map<DefinedElement, ? extends NodeRepresentation> previousNodeRepresentations,

+                int parallel) {

+                val Map<OutgoingRelation<NodeRepresentation>, Integer> res = Maps.mutable.of

+                for (outgoingConcreteEdge : OutgoingRelations.get(object)) {

+                        val OutgoingRelation<NodeRepresentation> e = new OutgoingRelation(

+                                previousNodeRepresentations.get(outgoingConcreteEdge.to), outgoingConcreteEdge.type)

+                        res.compute(e, [key, value | addOne(value, parallel)])

                 }

-                return res;

+                return res

         }

-        

+

         /*def private <KEY,VALUE> void addOrCreate_Set(Map<KEY,Set<VALUE>> map, KEY key, VALUE value) {

-                var Set<VALUE> s;

-                if(map.containsKey(key)) {

-                        s = map.get(key);

-                } else {

-                        s = new HashSet

-                        map.put(key,s)

-                }

-                s.add(value)

-        }*/

-        

-        

-        private def calculateFurtherNodeDescriptors(

-                PartialInterpretation model,

+         *      var Set<VALUE> s;

+         *      if(map.containsKey(key)) {

+         *              s = map.get(key);

+         *      } else {

+         *              s = new HashSet

+         *              map.put(key,s)

+         *      }

+         *      s.add(value)

+         }*/

+        private def calculateFurtherNodeDescriptors(PartialInterpretation model,

                 NeighbourhoodWithTraces<ModelRepresentation, NodeRepresentation> previous,

                 Map<DefinedElement, List<IncomingRelation<DefinedElement>>> IncomingRelations,

-                Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations,

-                int parallels, int maxNumber)

-        {

+                Map<DefinedElement, List<OutgoingRelation<DefinedElement>>> OutgoingRelations, int parallels, int maxNumber) {

                 val previousNodeRepresentations = previous.nodeRepresentations

-                val node2Representation = new HashMap<DefinedElement,FurtherNodeDescriptor<NodeRepresentation>>

-                val Map<FurtherNodeDescriptor<NodeRepresentation>,Integer> descriptor2Number = 

-                        if(this.mergeSimilarNeighbourhood){ new HashMap } else { null }

-                val Map<FurtherNodeDescriptor<NodeRepresentation>,FurtherNodeDescriptor<NodeRepresentation>> uniqueDescription =

-                        if(this.mergeSimilarNeighbourhood){     new HashMap } else { null }

-                

-                for(object: model.elements) {

-                        val incomingEdges = this.calculateIncomingEdges(IncomingRelations, object, previousNodeRepresentations,parallels)

-                        val outgoingEdges = this.calcuateOutgoingEdges(OutgoingRelations,object, previousNodeRepresentations,parallels)

-                        

+                val size = previousNodeRepresentations.size

+                val node2Representation = Maps.mutable.<DefinedElement, FurtherNodeDescriptor<NodeRepresentation>>ofInitialCapacity(size)

+                val Map<FurtherNodeDescriptor<NodeRepresentation>, Integer> descriptor2Number = if (this.

+                                mergeSimilarNeighbourhood) {

+                                Maps.mutable.ofInitialCapacity(size)

+                        } else {

+                                null

+                        }

+                val Map<FurtherNodeDescriptor<NodeRepresentation>, FurtherNodeDescriptor<NodeRepresentation>> uniqueDescription = if (this.

+                                mergeSimilarNeighbourhood) {

+                                Maps.mutable.ofInitialCapacity(size)

+                        } else {

+                                null

+                        }

+

+                for (object : model.elements) {

+                        val incomingEdges = this.calculateIncomingEdges(IncomingRelations, object, previousNodeRepresentations,

+                                parallels)

+                        val outgoingEdges = this.calcuateOutgoingEdges(OutgoingRelations, object, previousNodeRepresentations,

+                                parallels)

+

                         val previousType = previousNodeRepresentations.get(object)

-                        

-                        if(previousType === null) {

+

+                        if (previousType === null) {

                                 println("Error in state coder")

                         }

-                        

-                        val nodeDescriptor = new FurtherNodeDescriptor(

-                                previousType,

-                                incomingEdges,

-                                outgoingEdges)

-                        

-                        if(this.mergeSimilarNeighbourhood) {

-                                if(descriptor2Number.containsKey(nodeDescriptor)) {

+

+                        val nodeDescriptor = new FurtherNodeDescriptor(previousType, incomingEdges, outgoingEdges)

+

+                        if (this.mergeSimilarNeighbourhood) {

+                                if (descriptor2Number.containsKey(nodeDescriptor)) {

                                         descriptor2Number.put(

                                                 nodeDescriptor,

-                                                addOne(descriptor2Number.get(nodeDescriptor),maxNumber)

+                                                addOne(descriptor2Number.get(nodeDescriptor), maxNumber)

                                         )

-                                        node2Representation.put(object,uniqueDescription.get(nodeDescriptor))

+                                        node2Representation.put(object, uniqueDescription.get(nodeDescriptor))

                                 } else {

-                                        descriptor2Number.put(nodeDescriptor,if(1>maxNumber){Integer.MAX_VALUE}else{1})

-                                        uniqueDescription.put(nodeDescriptor,nodeDescriptor)

-                                        node2Representation.put(object,nodeDescriptor)

+                                        descriptor2Number.put(nodeDescriptor, if (1 > maxNumber) {

+                                                Integer.MAX_VALUE

+                                        } else {

+                                                1

+                                        })

+                                        uniqueDescription.put(nodeDescriptor, nodeDescriptor)

+                                        node2Representation.put(object, nodeDescriptor)

                                 }

                         } else {

-                                node2Representation.put(object,nodeDescriptor)

+                                node2Representation.put(object, nodeDescriptor)

                         }

                 }

-                

+

                 return descriptor2Number -> node2Representation

         }

-        

-        private def calculateLocalNodeDescriptors(

-                PartialInterpretation model,

-                Map<DefinedElement, Set<String>> types,

-                int maxNumber)

-        {

-                val Map<DefinedElement, LocalNodeDescriptor> node2Representation = new HashMap

-                val Map<LocalNodeDescriptor, Integer> representation2Amount =

-                        if(mergeSimilarNeighbourhood){ new HashMap } else { null }

-                val Map<LocalNodeDescriptor, LocalNodeDescriptor> uniqueRepresentation =

-                        if(this.mergeSimilarNeighbourhood){ new HashMap } else { null }

-                

-                for(element : model.elements) {

-                        var newDescriptor = new LocalNodeDescriptor(element.name,element.lookup(types))

-                        if(this.mergeSimilarNeighbourhood){

-                                if(uniqueRepresentation.containsKey(newDescriptor)) {

+

+        private def calculateLocalNodeDescriptors(PartialInterpretation model, Map<DefinedElement, Set<String>> types,

+                int maxNumber, DefinedElement focusedElement) {

+                val size = types.size

+                val Map<DefinedElement, LocalNodeDescriptor> node2Representation = Maps.mutable.ofInitialCapacity(size)

+                val Map<LocalNodeDescriptor, Integer> representation2Amount = if (mergeSimilarNeighbourhood) {

+                                Maps.mutable.ofInitialCapacity(size)

+                        } else {

+                                null

+                        }

+                val Map<LocalNodeDescriptor, LocalNodeDescriptor> uniqueRepresentation = if (this.mergeSimilarNeighbourhood) {

+                                Maps.mutable.ofInitialCapacity(size)

+                        } else {

+                                null

+                        }

+

+                for (element : model.elements) {

+                        val name = if(element == focusedElement) FOCUSED_ELEMENT_NAME else element.name

+                        var newDescriptor = new LocalNodeDescriptor(name, element.lookup(types))

+                        if (this.mergeSimilarNeighbourhood) {

+                                if (uniqueRepresentation.containsKey(newDescriptor)) {

                                         newDescriptor = newDescriptor.lookup(uniqueRepresentation)

-                                        node2Representation.put(element,newDescriptor)

+                                        node2Representation.put(element, newDescriptor)

                                         representation2Amount.put(

                                                 newDescriptor,

-                                                addOne(newDescriptor.lookup(representation2Amount),maxNumber)

+                                                addOne(newDescriptor.lookup(representation2Amount), maxNumber)

                                         )

                                 } else {

-                                        uniqueRepresentation.put(newDescriptor,newDescriptor)

-                                        node2Representation.put(element,newDescriptor)

-                                        representation2Amount.put(newDescriptor, if(1>maxNumber){Integer.MAX_VALUE}else{1})

+                                        uniqueRepresentation.put(newDescriptor, newDescriptor)

+                                        node2Representation.put(element, newDescriptor)

+                                        representation2Amount.put(newDescriptor, if (1 > maxNumber) {

+                                                Integer.MAX_VALUE

+                                        } else {

+                                                1

+                                        })

                                 }

                         } else {

-                                node2Representation.put(element,newDescriptor)

+                                node2Representation.put(element, newDescriptor)

                         }

                 }

-                

+

                 return representation2Amount -> node2Representation

         }

-}
\ No newline at end of file
+}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2PairwiseNeighbourhoodRepresentation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2PairwiseNeighbourhoodRepresentation.xtend
new file mode 100644
index 00000000..c10457b0
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/neighbourhood/PartialInterpretation2PairwiseNeighbourhoodRepresentation.xtend
@@ -0,0 +1,68 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood
+
+import com.google.common.collect.Maps
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import java.util.HashMap
+import java.util.Map
+import org.eclipse.xtend.lib.annotations.Data
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+@Data
+class PairwiseNeighbourhoodRepresentation<BasicNodeRepresentation> {
+        val Map<?, Integer> modelRepresentation
+        val Map<DefinedElement, BasicNodeRepresentation> basicNodeRepresentations
+        val Map<DefinedElement, ? extends Map<DefinedElement, ? extends BasicNodeRepresentation>> pairwiseNodeRepresentations
+
+        def getBasicRepresentation(DefinedElement a) {
+                basicNodeRepresentations.get(a)
+        }
+
+        def getPairwiseRepresentation(DefinedElement a, DefinedElement b) {
+                pairwiseNodeRepresentations.get(a).get(b)
+        }
+}
+
+@FinalFieldsConstructor
+class PartialInterpretation2PairwiseNeighbourhoodRepresentation<BasicNodeRepresentation> {
+        val PartialInterpretation2NeighbourhoodRepresentation<? extends Map<? extends BasicNodeRepresentation, Integer>, BasicNodeRepresentation> basicNeighbourhoodRepresenter
+
+        def createRepresentation(PartialInterpretation model, NeighbourhoodOptions options) {
+                val basicRepresentation = basicNeighbourhoodRepresenter.createRepresentation(model, options)
+                val basicModelRepresentation = basicRepresentation.modelRepresentation
+                val basicNodeRepresentations = basicRepresentation.nodeRepresentations
+                val pairwiseNodeRepresentations = Maps.newHashMapWithExpectedSize(basicNodeRepresentations.size)
+                val modelRepresentation = new HashMap<Object, Integer>
+                for (nodeWithBasicRepresentation : basicNodeRepresentations.entrySet) {
+                        val node = nodeWithBasicRepresentation.key
+                        val basicNodeRepresentation = nodeWithBasicRepresentation.value
+                        val count = basicModelRepresentation.get(basicNodeRepresentation)
+                        if (count == 1) {
+                                pairwiseNodeRepresentations.put(node, basicNodeRepresentations)
+                                modelRepresentation.put(basicNodeRepresentation, count)
+                        } else {
+                                val neighbourhoodRepresentation = basicNeighbourhoodRepresenter.
+                                        createRepresentationWithFocus(model, options, node)
+                                pairwiseNodeRepresentations.put(node, neighbourhoodRepresentation.nodeRepresentations)
+                                modelRepresentation.compute(neighbourhoodRepresentation.modelRepresentation) [ key, value |
+                                        if (value === null) {
+                                                if (1 > options.maxNumber) {
+                                                        Integer.MAX_VALUE
+                                                } else {
+                                                        1
+                                                }
+                                        } else {
+                                                addOne(value, options.maxNumber)
+                                        }
+                                ]
+                        }
+                }
+                new PairwiseNeighbourhoodRepresentation(modelRepresentation, basicNodeRepresentations,
+                        pairwiseNodeRepresentations)
+        }
+
+        def private addOne(int original, int max) {
+                if(original == Integer.MAX_VALUE) return Integer.MAX_VALUE
+                if(original + 1 > max) return Integer.MAX_VALUE else return original + 1
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/AbstractNeighborhoodBasedStateCoderFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/AbstractNeighborhoodBasedStateCoderFactory.xtend
new file mode 100644
index 00000000..089880b1
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/AbstractNeighborhoodBasedStateCoderFactory.xtend
@@ -0,0 +1,137 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder
+
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.NeighbourhoodOptions
+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.PartialRelationInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage
+import java.util.LinkedList
+import java.util.List
+import org.eclipse.emf.common.notify.Notifier
+import org.eclipse.emf.ecore.EClass
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.emf.ecore.EStructuralFeature
+import org.eclipse.viatra.dse.statecode.IStateCoder
+import org.eclipse.viatra.dse.statecode.IStateCoderFactory
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine
+import org.eclipse.viatra.query.runtime.base.api.FeatureListener
+import org.eclipse.viatra.query.runtime.base.api.IndexingLevel
+import org.eclipse.viatra.query.runtime.base.api.InstanceListener
+import org.eclipse.viatra.query.runtime.emf.EMFBaseIndexWrapper
+import org.eclipse.viatra.query.runtime.emf.EMFScope
+import org.eclipse.xtend.lib.annotations.Accessors
+
+abstract class AbstractNeighbourhoodBasedStateCoderFactory implements IStateCoderFactory {
+        val List<AbstractNeighbourhoodBasedPartialInterpretationStateCoder> statecoders = new LinkedList
+
+        val NeighbourhoodOptions options
+
+        protected new() {
+                this(NeighbourhoodOptions.DEFAULT)
+        }
+
+        protected new(NeighbourhoodOptions options) {
+                this.options = options
+        }
+
+        synchronized override createStateCoder() {
+                val res = doCreateStateCoder(options)
+                statecoders += res
+                return res
+        }
+
+        protected def AbstractNeighbourhoodBasedPartialInterpretationStateCoder doCreateStateCoder(
+                NeighbourhoodOptions options)
+
+        def getSumStatecoderRuntime() {
+                statecoders.map[statecoderRuntime].reduce[p1, p2|p1 + p2]
+        }
+}
+
+abstract class AbstractNeighbourhoodBasedPartialInterpretationStateCoder implements IStateCoder {
+        val NeighbourhoodOptions options
+
+        var PartialInterpretation target
+
+        protected new(NeighbourhoodOptions options) {
+                this.options = options
+        }
+
+        @Accessors(PUBLIC_GETTER) var long statecoderRuntime = 0
+
+        synchronized private def refreshStateCodes() {
+                if (refreshNeeded) {
+                        val startTime = System.nanoTime
+                        doRefreshStateCodes(target, options)
+                        statecoderRuntime += (System.nanoTime - startTime)
+                }
+        }
+
+        protected def boolean isRefreshNeeded()
+
+        protected def void doRefreshStateCodes(PartialInterpretation target, NeighbourhoodOptions options)
+
+        synchronized override createActivationCode(IPatternMatch match) {
+                refreshStateCodes
+                val startTime = System.nanoTime
+                val code = doCreateActivationCode(match)
+                statecoderRuntime += (System.nanoTime - startTime)
+                code
+        }
+
+        protected def Object doCreateActivationCode(IPatternMatch match)
+
+        synchronized override createStateCode() {
+                refreshStateCodes
+                doCreateStateCode
+        }
+
+        protected def Object doCreateStateCode()
+
+        override init(Notifier notifier) {
+                this.target = notifier as PartialInterpretation
+                val queryEngine = ViatraQueryEngine.on(new EMFScope(notifier))
+                val baseIndex = queryEngine.getBaseIndex() as EMFBaseIndexWrapper
+                val navigationHelper = baseIndex.getNavigationHelper();
+
+                val classes = PartialinterpretationPackage.eINSTANCE.EClassifiers.filter(EClass).toSet
+                val features = classes.map[it.EAllStructuralFeatures].flatten.toSet
+                navigationHelper.registerObservedTypes(classes, null, features, IndexingLevel.FULL);
+
+                navigationHelper.addFeatureListener(features, new FeatureListener() {
+                        override void featureInserted(EObject host, EStructuralFeature feature, Object value) { invalidate }
+
+                        override void featureDeleted(EObject host, EStructuralFeature feature, Object value) { invalidate }
+                })
+                navigationHelper.addInstanceListener(classes, new InstanceListener() {
+                        override void instanceInserted(EClass clazz, EObject instance) { invalidate }
+
+                        override void instanceDeleted(EClass clazz, EObject instance) { invalidate }
+                })
+        }
+
+        synchronized def invalidate() {
+                doInvalidate
+        }
+
+        protected def void doInvalidate()
+
+        def protected getFallbackCode(Object o) {
+                switch (o) {
+                        PartialInterpretation,
+                        LogicProblem:
+                                null
+                        PartialRelationInterpretation:
+                                o.interpretationOf.name
+                        PartialPrimitiveInterpretation:
+                                o.class.simpleName.hashCode
+                        PartialComplexTypeInterpretation:
+                                o.interpretationOf.name.hashCode
+                        default:
+                                throw new UnsupportedOperationException('''Unsupported type: «o.class.simpleName»''')
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend
index f55a501a..c7b8ee37 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/IdentifierBasedStateCoderFactory.xtend
@@ -62,13 +62,13 @@ class IdentifierBasedStateCode {
         int numberOfNewElement

         SortedSet<RelationStatecoder> relationStatecoders

         

-        private static val comparator = new Comparator<RelationStatecoder>() {

+        static val comparator = new Comparator<RelationStatecoder>() {

                 override compare(RelationStatecoder o1, RelationStatecoder o2) {

                         o1.relationName.compareTo(o2.relationName)

                 }

         }

         

-        public new(int numberOfNewElements) {

+        new(int numberOfNewElements) {

                 this.numberOfNewElement = numberOfNewElements

                 this.relationStatecoders = new TreeSet(comparator)

         }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend
index a86bcd1f..04c49506 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/NeighbourhoodBasedStateCoderFactory.xtend
@@ -1,223 +1,109 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder
 
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.AbstractNodeDescriptor
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.NeighbourhoodOptions
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2Hash
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2ImmutableTypeLattice
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2NeighbourhoodRepresentation
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage
 import java.util.ArrayList
-import java.util.LinkedList
-import java.util.List
 import java.util.Map
-import org.eclipse.emf.common.notify.Notifier
-import org.eclipse.emf.ecore.EClass
-import org.eclipse.emf.ecore.EObject
-import org.eclipse.emf.ecore.EStructuralFeature
-import org.eclipse.viatra.dse.statecode.IStateCoder
-import org.eclipse.viatra.dse.statecode.IStateCoderFactory
 import org.eclipse.viatra.query.runtime.api.IPatternMatch
-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine
-import org.eclipse.viatra.query.runtime.base.api.FeatureListener
-import org.eclipse.viatra.query.runtime.base.api.IndexingLevel
-import org.eclipse.viatra.query.runtime.base.api.InstanceListener
-import org.eclipse.viatra.query.runtime.emf.EMFBaseIndexWrapper
-import org.eclipse.viatra.query.runtime.emf.EMFScope
-import org.eclipse.xtend.lib.annotations.Accessors
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement
-import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation
-import java.util.Set
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2NeighbourhoodRepresentation
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
 
-class NeighbourhoodBasedStateCoderFactory implements IStateCoderFactory {
-        val List<NeighbourhoodBasedPartialInterpretationStateCoder> statecoders = new LinkedList
-        
-        val int range
-        val int parallels
-        val int maxNumber
-        val Set<TypeDeclaration> relevantTypes
-        val Set<RelationDeclaration> relevantRelations
-        
-        public new() {
-                this.range = PartialInterpretation2NeighbourhoodRepresentation::GraphWidthRange
-                this.parallels = PartialInterpretation2NeighbourhoodRepresentation::FullParallels
-                this.maxNumber = PartialInterpretation2NeighbourhoodRepresentation::MaxNumbers
-                this.relevantTypes = null
-                this.relevantRelations = null
+class NeighbourhoodBasedStateCoderFactory extends AbstractNeighbourhoodBasedStateCoderFactory {
+        new() {
         }
-        
-        public new(int range, int parallels, int maxNumber, Set<TypeDeclaration> relevantTypes, Set<RelationDeclaration> relevantRelations) {
-                this.range = range
-                this.parallels = parallels
-                this.maxNumber = maxNumber
-                this.relevantTypes = relevantTypes
-                this.relevantRelations = relevantRelations
+
+        new(NeighbourhoodOptions options) {
+                super(options)
+        }
+
+        override protected doCreateStateCoder(NeighbourhoodOptions options) {
+                new NeighbourhoodBasedPartialInterpretationStateCoder(new PartialInterpretation2ImmutableTypeLattice, options)
         }
-        
-    synchronized override createStateCoder() {
-        val res = new NeighbourhoodBasedPartialInterpretationStateCoder(statecoders.size,
-                range,parallels,maxNumber,relevantTypes,relevantRelations)
-        statecoders += res
-        return res
-    }
-    def getSumStatecoderRuntime() {
-        statecoders.map[statecoderRuntime].reduce[p1, p2|p1+p2]
-    }
 }
 
-class NeighbourhoodBasedPartialInterpretationStateCoder implements IStateCoder{
-        val int id;
-        val int range
-        val int parallels
-        val int maxNumber
-        val Set<TypeDeclaration> relevantTypes
-        val Set<RelationDeclaration> relevantRelations
-        
-        val calculator =
-        new PartialInterpretation2ImmutableTypeLattice
-    var PartialInterpretation target
-        
-        private var Map<DefinedElement, ? extends AbstractNodeDescriptor> nodeRepresentations = null
-        private var Map<? extends AbstractNodeDescriptor, Integer> modelRepresentation = null
-        
-        /*public new(int id) {
-                this.id = id
-                this.range = PartialInterpretation2NeighbourhoodRepresentation::FixPointRage
-                this.parallels = PartialInterpretation2NeighbourhoodRepresentation::FullParallels
-                this.maxNumber = maxNumber = PartialInterpretation2NeighbourhoodRepresentation::MaxNumbers
-                this.relevantTypes = relevantTypes
-                this.relevantRelations = relevantRelations
-        }*/
+class NeighbourhoodBasedHashStateCoderFactory extends AbstractNeighbourhoodBasedStateCoderFactory {
+        new() {
+        }
+
+        new(NeighbourhoodOptions options) {
+                super(options)
+        }
+
+        override protected doCreateStateCoder(NeighbourhoodOptions options) {
+                new NeighbourhoodBasedPartialInterpretationStateCoder(new PartialInterpretation2Hash, options)
+        }
+}
+
+class NeighbourhoodBasedPartialInterpretationStateCoder<ModelRep, NodeRep> extends AbstractNeighbourhoodBasedPartialInterpretationStateCoder {
+        val PartialInterpretation2NeighbourhoodRepresentation<ModelRep, NodeRep> calculator
+        val Map<IQuerySpecification<?>, String> fullyQualifiedNames = newHashMap
+        var Map<DefinedElement, ? extends NodeRep> nodeRepresentations = null
+        var ModelRep modelRepresentation = null
+
+        new(PartialInterpretation2NeighbourhoodRepresentation<ModelRep, NodeRep> calculator, NeighbourhoodOptions options) {
+                super(options)
+                this.calculator = calculator
+        }
+
+        override protected isRefreshNeeded() {
+                nodeRepresentations === null || modelRepresentation === null
+        }
+
+        override doRefreshStateCodes(PartialInterpretation target, NeighbourhoodOptions options) {
+                val code = calculator.createRepresentation(target, options)
+                modelRepresentation = code.modelRepresentation
+                nodeRepresentations = code.nodeRepresentations
+        }
         
-        public new(int id, int range, int parallels, int maxNumber, Set<TypeDeclaration> relevantTypes, Set<RelationDeclaration> relevantRelations) {
-                this.id = id
-                this.range = range
-                this.parallels = parallels
-                this.maxNumber = maxNumber
-                this.relevantTypes = relevantTypes
-                this.relevantRelations = relevantRelations
+        private def getFullyQualifiedNameCached(IQuerySpecification<?> specification) {
+                fullyQualifiedNames.computeIfAbsent(specification, [fullyQualifiedName])
         }
-    
-    @Accessors(PUBLIC_GETTER) var long statecoderRuntime = 0
-         
-//    val range = -1
-//    val par = Integer.MAX_VALUE
-    //val deeprepresentation = false
-
-    /////////
-    // Caching version
-    /////////
-    synchronized private def refreshStateCodes() {
-        if(this.nodeRepresentations === null || this.modelRepresentation === null) {
-                val startTime = System.nanoTime
-                //relevantObjects.forEach[println(it)]
-                val code = calculator.createRepresentation(target,range,parallels,maxNumber,relevantTypes,relevantRelations)
-                this.modelRepresentation = code.modelRepresentation
-                this.nodeRepresentations = code.nodeRepresentations
-                statecoderRuntime += (System.nanoTime - startTime)
-        }
-    }
-    synchronized override createActivationCode(IPatternMatch match) {
-        refreshStateCodes
-        
-        val startTime = System.nanoTime
-        val size = match.specification.parameters.size
-        val res = new ArrayList(size)
-        var int index = 0
-        var int equivalenceHash = 0
-        val prime = 31
-                
-        while(index < size) {
-                res.add(getCode(match.get(index)))
-                index++
-                for(var i = 0; i<index; i++) {
-                        val number = if(match.get(index) === match.get(i)){1}else{0}
-                        equivalenceHash = prime * equivalenceHash + number
-                }
-        }
-        
-        statecoderRuntime += (System.nanoTime - startTime)
-        return match.specification.fullyQualifiedName->(res->equivalenceHash).hashCode
-    }
-    
-    
-    def private getCode(Object o) {
-        if(o instanceof DefinedElement) {
-                this.nodeRepresentations.get(o)
-        } else if(o instanceof PartialInterpretation || o instanceof LogicProblem) {
-                        return null
-                } else if(o instanceof PartialRelationInterpretation) {
-                        return o.interpretationOf.name
-                } else if(o instanceof PartialTypeInterpratation) {
-                        if(o instanceof PartialPrimitiveInterpretation) {
-                                o.class.simpleName.hashCode
-                        } else if (o instanceof PartialComplexTypeInterpretation){
-                                return o.interpretationOf.name.hashCode
+
+        override doCreateActivationCode(IPatternMatch match) {
+                val size = match.specification.parameters.size
+                var int hash = 0
+                val prime = 31
+
+                for (var int index = 0; index < size; index++) {
+                        val matchArgument = match.get(index)
+                        val code = getCode(matchArgument)
+                        val codeNumber = if (code === null) {
+                                0
                         } else {
-                                throw new UnsupportedOperationException('''Unsupported type: «o.class.simpleName»''')
+                                code.hashCode
+                        }
+                        hash = prime * hash + codeNumber
+                        for (var i = 0; i < index; i++) {
+                                val number = if (matchArgument === match.get(i)) {
+                                                1
+                                        } else {
+                                                0
+                                        }
+                                hash = prime * hash + number
                         }
-                } else {
-                        throw new UnsupportedOperationException('''Unsupported type: «o.class.simpleName»''')
                 }
-    }
-    
-    synchronized override createStateCode() {
-        refreshStateCodes
-        return this.modelRepresentation.hashCode
-    }
-        /////////
-    // Caching version
-    /////////
-
-    /////////
-    // Recalculating version
-    /////////
-//    synchronized override createActivationCode(IPatternMatch match) {
-//      val nodes = calculator.createRepresentation(getRelevantObjects().toList,range,par).nodeRepresentations
-//        val res = match.toArray.map[objectInMatch |
-//              nodes.get(objectInMatch)
-//        ]
-//        return res
-//    }
-//    
-//    override createStateCode() {
-//      return this.calculator.createRepresentation(getRelevantObjects().toList,range,par).modelRepresentation
-//    }
-    /////////
-    // Recalculating version
-    /////////
-    
-    override init(Notifier notifier) {
-        this.target = notifier as PartialInterpretation
-        val queryEngine = ViatraQueryEngine.on(new EMFScope(notifier))
-        val baseIndex = queryEngine.getBaseIndex() as EMFBaseIndexWrapper
-        val navigationHelper = baseIndex.getNavigationHelper();
-        
-        val classes = PartialinterpretationPackage.eINSTANCE.EClassifiers.filter(EClass).toSet
-        val features = classes.map[it.EAllStructuralFeatures].flatten.toSet
-        navigationHelper.registerObservedTypes(
-                classes,
-                null,
-                features,
-                IndexingLevel.FULL);
-
-
-        navigationHelper.addFeatureListener(features, new FeatureListener() {
-            override public void featureInserted(EObject host, EStructuralFeature feature, Object value) { invalidate }
-            override public void featureDeleted(EObject host, EStructuralFeature feature, Object value) { invalidate }
-        });
-        navigationHelper.addInstanceListener(classes, new InstanceListener() {
-            override public void instanceInserted(EClass clazz, EObject instance) { invalidate }
-            override public void instanceDeleted(EClass clazz, EObject instance) { invalidate }
-        });
-    }
-        
-        synchronized def public invalidate() {
-                this.nodeRepresentations = null
-        this.modelRepresentation = null
+
+                match.specification.fullyQualifiedNameCached -> hash
+        }
+
+        def private getCode(Object o) {
+                switch (o) {
+                        DefinedElement:
+                                nodeRepresentations.get(o)
+                        default:
+                                getFallbackCode(o)
+                }
+        }
+
+        override doCreateStateCode() {
+                modelRepresentation.hashCode
+        }
+
+        override doInvalidate() {
+                nodeRepresentations = null
+                modelRepresentation = null
         }
 }
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/PairwiseNeighbourhoodBasedStateCoderFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/PairwiseNeighbourhoodBasedStateCoderFactory.xtend
new file mode 100644
index 00000000..84e798f2
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/statecoder/PairwiseNeighbourhoodBasedStateCoderFactory.xtend
@@ -0,0 +1,75 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder
+
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.AbstractNodeDescriptor
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.NeighbourhoodOptions
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PairwiseNeighbourhoodRepresentation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2ImmutableTypeLattice
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2PairwiseNeighbourhoodRepresentation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import java.util.ArrayList
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+
+class PairwiseNeighbourhoodBasedStateCoderFactory extends AbstractNeighbourhoodBasedStateCoderFactory {
+        new() {
+        }
+
+        new(NeighbourhoodOptions options) {
+                super(options)
+        }
+
+        override protected doCreateStateCoder(NeighbourhoodOptions options) {
+                new PairwiseNeighbourhoodBasedPartialInterpretationStateCoder(options)
+        }
+}
+
+class PairwiseNeighbourhoodBasedPartialInterpretationStateCoder extends AbstractNeighbourhoodBasedPartialInterpretationStateCoder {
+        val calculator = new PartialInterpretation2PairwiseNeighbourhoodRepresentation(
+                new PartialInterpretation2ImmutableTypeLattice)
+        var PairwiseNeighbourhoodRepresentation<? extends AbstractNodeDescriptor> representation
+
+        new(NeighbourhoodOptions options) {
+                super(options)
+        }
+
+        override protected isRefreshNeeded() {
+                representation === null
+        }
+
+        override protected doRefreshStateCodes(PartialInterpretation target, NeighbourhoodOptions options) {
+                representation = calculator.createRepresentation(target, options)
+        }
+
+        override protected doCreateActivationCode(IPatternMatch match) {
+                val size = match.specification.parameters.size
+                val res = new ArrayList(size * size)
+                for (var int i = 0; i < size; i++) {
+                        val a = match.get(i)
+                        for (var int j = 0; j < size; j++) {
+                                val b = match.get(j)
+                                res.add(getPairwiseRepresentation(a, b))
+                        }
+                }
+                match.specification.fullyQualifiedName -> res.hashCode
+        }
+
+        private def getPairwiseRepresentation(Object a, Object b) {
+                if (b instanceof DefinedElement) {
+                        if (a instanceof DefinedElement) {
+                                representation.getPairwiseRepresentation(a, b)
+                        } else {
+                                representation.getBasicRepresentation(b)
+                        }
+                } else {
+                        getFallbackCode(b)
+                }
+        }
+
+        override protected doCreateStateCode() {
+                representation.modelRepresentation.hashCode
+        }
+
+        override protected doInvalidate() {
+                representation = null
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend
index 2b42a8b1..bdf402f3 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/visualisation/PartialInterpretation2Gml.xtend
@@ -5,9 +5,13 @@ 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.logiclanguage.TypeDefinition

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BooleanElement

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.IntegerElement

 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.PartialRelationInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.RealElement

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.StringElement

 import java.util.HashMap

 import java.util.Map

 import java.util.Set

@@ -106,10 +110,38 @@ class PartialInterpretation2Gml {
                 '''

         }

         

-        def protected transormTitle(DefinedElement object) {

-                if(object.name!= null)object.name

+        def protected dispatch transormTitle(DefinedElement object) {

+                if(object.name !== null) object.name.replace("\"", "")

                 else "null"

         }

+        def protected dispatch transormTitle(BooleanElement object) {

+                if(object.valueSet) {

+                        object.value.toString

+                } else {

+                        "?"

+                }

+        }

+        def protected dispatch transormTitle(IntegerElement object) {

+                if(object.valueSet) {

+                        object.value.toString

+                } else {

+                        "?"

+                }

+        }

+        def protected dispatch transormTitle(RealElement object) {

+                if(object.valueSet) {

+                        object.value.toString

+                } else {

+                        "?"

+                }

+        }

+        def protected dispatch transormTitle(StringElement object) {

+                if(object.valueSet) {

+                        object.value.toString

+                } else {

+                        "?"

+                }

+        }

         

         def protected transformLink(

                 PartialRelationInterpretation reference,

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 7077ae34..185dac40 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,9 @@ 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.dse,
+ 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..691e0645 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,10 @@
-package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner

-

-import org.eclipse.viatra.dse.objectives.IGlobalConstraint

-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationMethod

-

-abstract class ModelGenerationMethodBasedGlobalConstraint implements IGlobalConstraint {

-        val protected ModelGenerationMethod method

-        new(ModelGenerationMethod method) {

-                this.method = method

-        }

-}
\ No newline at end of file
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner
+
+import org.eclipse.viatra.dse.objectives.IGlobalConstraint
+
+abstract class ModelGenerationMethodBasedGlobalConstraint implements IGlobalConstraint {
+        val protected ModelGenerationMethod method
+        new(ModelGenerationMethod method) {
+                this.method = method
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ModelGenerationMethodProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ModelGenerationMethodProvider.xtend
new file mode 100644
index 00000000..25137eba
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ModelGenerationMethodProvider.xtend
@@ -0,0 +1,201 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner
+
+import com.google.common.collect.ImmutableMap
+import com.google.common.collect.ImmutableSet
+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.ModelGenerationStatistics
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.CachingSimplePolyhedronScopePropagatorStrategy
+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.PolyhedronExtensionOperator
+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
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.DiversityChecker
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.ViatraReasonerSolutionSaver
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ThreeValuedCostObjectiveProvider
+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.dse.objectives.IObjective
+import org.eclipse.viatra.query.runtime.api.GenericQueryGroup
+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.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 hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ExtendedPolyhedronScopePropagatorStrategy
+
+@Data class ModelGenerationMethod {
+        ModelGenerationStatistics statistics
+
+        Collection<? extends BatchTransformationRule<?, ?>> objectRefinementRules
+        Collection<? extends BatchTransformationRule<?, ?>> relationRefinementRules
+
+        List<MultiplicityGoalConstraintCalculator> unfinishedMultiplicities
+
+        Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWF
+
+        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<String, ModalPatternQueries> modalRelationQueries
+
+        Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allPatterns
+
+        Collection<IObjective> costObjectives
+        boolean optimizationProblem
+        ViatraReasonerSolutionSaver solutionSaver
+}
+
+class ModelGenerationMethodProvider {
+        val PatternProvider patternProvider = new PatternProvider
+        val RefinementRuleProvider refinementRuleProvider = new RefinementRuleProvider
+        val GoalConstraintProvider goalConstraintProvider = new GoalConstraintProvider
+        val relationConstraintCalculator = new RelationConstraintCalculator
+
+        def ModelGenerationMethod createModelGenerationMethod(
+                LogicProblem logicProblem,
+                PartialInterpretation emptySolution,
+                ReasonerWorkspace workspace,
+                ViatraReasonerConfiguration config
+        ) {
+                val statistics = new ModelGenerationStatistics
+                val debugLevel = config.documentationLevel
+                val writeFiles = (debugLevel === DocumentationLevel.NORMAL || debugLevel === DocumentationLevel.FULL)
+
+                val Set<PQuery> existingQueries = logicProblem.relations.map[annotations].flatten.filter(TransfomedViatraQuery).
+                        map[it.patternPQuery as PQuery].toSet
+
+                val relationConstraints = relationConstraintCalculator.calculateRelationConstraints(logicProblem)
+                val queries = patternProvider.generateQueries(logicProblem, emptySolution, statistics, existingQueries,
+                        workspace, config.typeInferenceMethod, config.scopePropagatorStrategy, relationConstraints, config.hints,
+                        config.unitPropagationPatternGenerators, writeFiles)
+
+                val unfinishedMultiplicities = goalConstraintProvider.getUnfinishedMultiplicityQueries(logicProblem, queries,
+                        config.calculateObjectCreationCosts)
+                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
+                val queriesToPrepare = ImmutableSet.builder.addAll(queries.refineObjectQueries.values).addAll(
+                        queries.refineTypeQueries.values).addAll(queries.refineRelationQueries.values).addAll(
+                        queries.mustRelationPropagationQueries.values).addAll(queries.multiplicityConstraintQueries.values.flatMap [
+                        allQueries
+                ]).addAll(queries.unfinishedWFQueries.values).addAll(queries.invalidWFQueries.values).addAll(
+                        queries.mustUnitPropagationPreconditionPatterns.values).addAll(
+                        queries.currentUnitPropagationPreconditionPatterns.values).add(queries.hasElementInContainmentQuery).build
+                val queryEngine = ViatraQueryEngine.on(new EMFScope(emptySolution))
+                GenericQueryGroup.of(queriesToPrepare).prepare(queryEngine)
+
+                val objectiveProvider = new ThreeValuedCostObjectiveProvider(queryEngine, emptySolution, modalRelationQueries)
+                val transformedObjectives = objectiveProvider.getCostObjectives(config.costObjectives)
+
+                val solutionSaver = new ViatraReasonerSolutionSaver(transformedObjectives.leveledExtremalObjectives,
+                        config.solutionScope.numberOfRequiredSolutions, DiversityChecker.of(config.diversityRequirement))
+
+                val allHints = ImmutableSet.builder
+                allHints.addAll(config.hints)
+                for (hint : transformedObjectives.hints) {
+                        hint.boundsProvider = solutionSaver
+                        allHints.add(hint)
+                }
+
+                val scopePropagator = createScopePropagator(config.scopePropagatorStrategy, emptySolution, allHints.build,
+                        transformedObjectives.extensionOperators, queries, statistics)
+                scopePropagator.propagateAllScopeConstraints
+                val unitRulePropagator = refinementRuleProvider.createUnitPrulePropagator(logicProblem, emptySolution, queries,
+                        scopePropagator, statistics)
+                val objectRefinementRules = refinementRuleProvider.createObjectRefinementRules(logicProblem, emptySolution,
+                        queries, unitRulePropagator, config.nameNewElements, statistics)
+                val relationRefinementRules = refinementRuleProvider.createRelationRefinementRules(queries, unitRulePropagator,
+                        statistics)
+
+                return new ModelGenerationMethod(
+                        statistics,
+                        objectRefinementRules.values,
+                        relationRefinementRules.values,
+                        unfinishedMultiplicities,
+                        unfinishedWF,
+                        invalidWF,
+                        mustUnitPropagationPreconditions,
+                        currentUnitPropagationPreconditions,
+                        modalRelationQueries,
+                        queries.allQueries,
+                        transformedObjectives.objectives,
+                        transformedObjectives.optimizationProblem,
+                        solutionSaver
+                )
+        }
+
+        private def createScopePropagator(ScopePropagatorStrategy scopePropagatorStrategy,
+                PartialInterpretation emptySolution, Collection<LinearTypeConstraintHint> hints,
+                Collection<PolyhedronExtensionOperator> extensionOperators, 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)
+                                }
+                                val strategy = if (extensionOperators.empty) {
+                                                new CachingSimplePolyhedronScopePropagatorStrategy(solver, statistics)
+                                        } else {
+                                                new ExtendedPolyhedronScopePropagatorStrategy(solver, extensionOperators, statistics)
+                                        }
+                                new PolyhedronScopePropagator(emptySolution, statistics, types, queries.multiplicityConstraintQueries,
+                                        queries.hasElementInContainmentQuery, allPatternsByName, hints, strategy,
+                                        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.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 4331420d..4d2fd741 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
@@ -10,20 +10,28 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
 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.HillClimbingOnRealisticMetricStrategyForModelGeneration

+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.NumericSolver

 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.PartialModelAsLogicInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.PunishSizeObjective

 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.WF2ObjectiveConverter

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveKind

 import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace

 import java.util.List

 import java.util.Map

@@ -34,193 +42,320 @@ import org.eclipse.viatra.dse.api.DesignSpaceExplorer.DseLoggingLevel
 import org.eclipse.viatra.dse.solutionstore.SolutionStore

 import org.eclipse.viatra.dse.statecode.IStateCoderFactory

 

-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, ReasonerWorkspace workspace) throws LogicReasonerException {

+

+        override solve(LogicProblem problem, LogicSolverConfiguration configuration,

+                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 || viatraConfig.documentationLevel == DocumentationLevel::NORMAL) && workspace !== null) {

-                        workspace.writeModel(emptySolution,"init.partialmodel")

-                } 

+                val emptySolution = initialiser.initialisePartialInterpretation(problem, viatraConfig.typeScopes).output

+                if ((viatraConfig.documentationLevel == DocumentationLevel::FULL ||

+                        viatraConfig.documentationLevel == DocumentationLevel::NORMAL) && workspace !== null) {

+                        workspace.writeModel(emptySolution, "init.partialmodel")

+                }

+

                 emptySolution.problemConainer = problem

                 val emptySolutionCopy = EcoreUtil.copy(emptySolution)

+                

                 val ScopePropagator scopePropagator = new ScopePropagator(emptySolution)

                 scopePropagator.propagateAllScopeConstraints            

                 

+                var BasicScopeGlobalConstraint basicScopeGlobalConstraint = null

+                if (viatraConfig.scopePropagatorStrategy == ScopePropagatorStrategy.None) {

+                        basicScopeGlobalConstraint = new BasicScopeGlobalConstraint(emptySolution)

+                        emptySolution.scopes.clear

+                }

+

                 val method = modelGenerationMethodProvider.createModelGenerationMethod(

                         problem,

                         emptySolution,

                         workspace,

-                        viatraConfig.nameNewElements,

-                        viatraConfig.typeInferenceMethod,

-                        scopePropagator,

-                        viatraConfig.documentationLevel

+                        viatraConfig

                 )

-                

-                dse.addObjective(new ModelGenerationCompositeObjective(

-                        new ScopeObjective,

+

+                val compositeObjective = new ModelGenerationCompositeObjective(

+                        basicScopeGlobalConstraint ?: new ScopeObjective,

                         method.unfinishedMultiplicities.map[new UnfinishedMultiplicityObjective(it)],

-                        new UnfinishedWFObjective(method.unfinishedWF),

-                        viatraConfig.isWFOptional

-                ))

+                        wf2ObjectiveConverter.createCompletenessObjective(method.unfinishedWF),

+                        viatraConfig

+                )

+                dse.addObjective(compositeObjective)

+                if (viatraConfig.punishSize != PunishSizeStrategy.NONE) {

+                        val punishSizeStrategy = switch (viatraConfig.punishSize) {

+                                case SMALLER_IS_BETTER: ObjectiveKind.LOWER_IS_BETTER

+                                case LARGER_IS_BETTER: ObjectiveKind.HIGHER_IS_BETTER

+                                default: throw new IllegalArgumentException("Unknown PunishSizeStrategy: " + viatraConfig.punishSize)

+                        }

+                        val punishObjective = new PunishSizeObjective(punishSizeStrategy, compositeObjective.level + 1)

+                        dse.addObjective(punishObjective)

+                }

 

-                dse.addGlobalConstraint(wf2ObjectiveConverter.createInvalidationObjective(method.invalidWF))

-                for(additionalConstraint : viatraConfig.searchSpaceConstraints.additionalGlobalConstraints) {

+                for (costObjective : method.costObjectives) {

+                        dse.addObjective(costObjective)

+                }

+                val numberOfRequiredSolutions = configuration.solutionScope.numberOfRequiredSolutions

+                val solutionStore = if (method.optimizationProblem) {

+                                new SolutionStore()

+                        } else {

+                                new SolutionStore(numberOfRequiredSolutions)

+                        }

+                solutionStore.registerSolutionFoundHandler(new LoggerSolutionFoundHandler(viatraConfig))

+                val numericSolver = new NumericSolver(method, viatraConfig.runIntermediateNumericalConsistencyChecks, false)

+                val solutionSaver = method.solutionSaver

+                solutionSaver.numericSolver = numericSolver

+                val solutionCopier = solutionSaver.solutionCopier

+                val diversityChecker = solutionSaver.diversityChecker

+                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)

-                

-                val IStateCoderFactory statecoder = if(viatraConfig.stateCoderStrategy == StateCoderStrategy.Neighbourhood) {

-                        new NeighbourhoodBasedStateCoderFactory

-                } else {

-                        new IdentifierBasedStateCoderFactory

+

+                dse.setInitialModel(emptySolution, false)

+

+                val IStateCoderFactory statecoder = switch (viatraConfig.stateCoderStrategy) {

+                        case Neighbourhood:

+                                new NeighbourhoodBasedHashStateCoderFactory

+                        case PairwiseNeighbourhood:

+                                new PairwiseNeighbourhoodBasedStateCoderFactory

+                        default:

+                                new IdentifierBasedStateCoderFactory

                 }

                 dse.stateCoderFactory = statecoder

-                

+

                 dse.maxNumberOfThreads = 1

-                

-                val solutionStore =  new SolutionStore(configuration.solutionScope.numberOfRequiredSolution)

-                dse.solutionStore = solutionStore

-                

-                for(rule : method.relationRefinementRules) {

+

+                for (rule : method.relationRefinementRules) {

                         dse.addTransformationRule(rule)

                 }

-                for(rule : method.objectRefinementRules) {

+                for (rule : method.objectRefinementRules) {

                         dse.addTransformationRule(rule)

                 }

                 

                 val strategy = new HillClimbingOnRealisticMetricStrategyForModelGeneration(workspace,viatraConfig,method)

                 viatraConfig.progressMonitor.workedForwardTransformation

-                

-                val transformationTime = System.nanoTime - transformationStartTime

+                val transformationFinished = System.nanoTime

+                val transformationTime = transformationFinished - transformationStartTime

                 val solverStartTime = System.nanoTime

-                

+

                 var boolean stoppedByTimeout

-                var boolean stoppedByException

-                try{

-                        stoppedByTimeout = dse.startExplorationWithTimeout(strategy,configuration.runtimeLimit*1000);

-                        stoppedByException = false

+                try {

+                        stoppedByTimeout = dse.startExplorationWithTimeout(strategy, configuration.runtimeLimit * 1000);

                 } catch (NullPointerException npe) {

                         stoppedByTimeout = false

-                        stoppedByException = true

                 }

                 val solverTime = System.nanoTime - solverStartTime

                 viatraConfig.progressMonitor.workedSearchFinished

-                

-                //find trajectory to each solution

-                if(viatraConfig.documentationLevel == DocumentationLevel.NONE){

-                        PartialInterpretationMetric.initPaths();

-                        //PartialInterpretationMetric.outputTrajectories(emptySolutionCopy, dse.solutions.toList());

-                }

-                

-                //additionalMatches = strategy.solutionStoreWithCopy.additionalMatches

+

+                // additionalMatches = strategy.solutionStoreWithCopy.additionalMatches

                 val statistics = createStatistics => [

-                        //it.solverTime = viatraConfig.runtimeLimit

-                        it.solverTime = (solverTime/1000000) as int

-                        it.transformationTime = (transformationTime/1000000) as int

-                        for(x : 0..<strategy.solutionStoreWithCopy.allRuntimes.size) {

+                        // it.solverTime = viatraConfig.runtimeLimit

+                        it.solverTime = (solverTime / 1000000) as int

+                        it.transformationTime = (transformationTime / 1000000) as int

+                        for (pair : solutionCopier.getAllCopierRuntimes(true).indexed) {

                                 it.entries += createIntStatisticEntry => [

-                                        it.name = '''_Solution«x»FoundAt'''

-                                        it.value = (strategy.solutionStoreWithCopy.allRuntimes.get(x)/1000000) as int

+                                        it.name = '''Solution«pair.key»FoundAt'''

+                                        it.value = (pair.value / 1000000) as int

                                 ]

                         }

+                        for (x : 0 ..< strategy.times.size) {

+                                it.entries += createStringStatisticEntry => [

+                                        it.name = '''Solution«x+1»DetailedStatistics'''

+                                        it.value = strategy.times.get(x)

+                                ]

+                        }

+                        it.entries += createIntStatisticEntry => [

+                                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.entries += createIntStatisticEntry => [

+                                it.name = "ScopePropagationTime"

+                                it.value = (method.statistics.scopePropagationTime / 1000000) as int

+                        ]

+                        it.entries += createIntStatisticEntry => [

+                                it.name = "MustRelationPropagationTime"

+                                it.value = (method.statistics.mustRelationPropagationTime / 1000000) as int

+                        ]

+                        it.entries += createIntStatisticEntry => [

+                                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.entries += createIntStatisticEntry => [

+                                it.name = "StateCoderFailCount"

+                                it.value = strategy.numberOfStatecoderFail

+                        ]

                         it.entries += createIntStatisticEntry => [

-                                it.name = "TransformationExecutionTime" it.value = (method.statistics.transformationExecutionTime/1000000) as int

+                                it.name = "SolutionCopyTime"

+                                it.value = (solutionCopier.getTotalCopierRuntime / 1000000) as int

                         ]

                         it.entries += createIntStatisticEntry => [

-                                it.name = "TypeAnalysisTime" it.value = (method.statistics.PreliminaryTypeAnalisisTime/1000000) as int

+                                it.name = "States"

+                                it.value = dse.numberOfStates as int

+                        ]

+                        it.entries += createIntStatisticEntry => [

+                                it.name = "ForwardTime"

+                                it.value = (strategy.forwardTime / 1000000) as int

+                        ]

+                        it.entries += createIntStatisticEntry => [

+                                it.name = "BacktrackingTime"

+                                it.value = (strategy.backtrackingTime / 1000000) as int

+                        ]

+                        it.entries += createIntStatisticEntry => [

+                                it.name = "GlobalConstraintEvaluationTime"

+                                it.value = (strategy.globalConstraintEvaluationTime / 1000000) as int

+                        ]

+                        it.entries += createIntStatisticEntry => [

+                                it.name = "FitnessCalculationTime"

+                                it.value = (strategy.fitnessCalculationTime / 1000000) as int

+                        ]

+                        it.entries += createIntStatisticEntry => [

+                                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 = "MetricCalculationTime" it.value = (method.statistics.metricCalculationTime/1000000) as int

                         ]

                         it.entries += createIntStatisticEntry => [

-                                it.name = "StateCoderTime" it.value = (statecoder.runtime/1000000) as int

+                                it.name = "Transformations"

+                                it.value = method.statistics.transformationInvocations

                         ]

                         it.entries += createIntStatisticEntry => [

-                                it.name = "StateCoderFailCount" it.value = strategy.numberOfStatecoderFail

+                                it.name = "ScopePropagations"

+                                it.value = method.statistics.scopePropagatorInvocations

                         ]

                         it.entries += createIntStatisticEntry => [

-                                it.name = "SolutionCopyTime" it.value = (strategy.solutionStoreWithCopy.sumRuntime/1000000) as int

+                                it.name = "ScopePropagationsSolverCalls"

+                                it.value = method.statistics.scopePropagatorSolverInvocations

                         ]

-                        if(strategy.solutionStoreWithDiversityDescriptor.isActive) {

+//                      it.entries += createIntStatisticEntry => [

+//                              it.name = "NumericalSolverSumTime"

+//                              it.value = (strategy.numericSolver.runtime / 1000000) as int

+//                      ]

+//                      it.entries += createIntStatisticEntry => [

+//                              it.name = "NumericalSolverProblemFormingTime"

+//                              it.value = (strategy.numericSolver.solverFormingProblem / 1000000) as int

+//                      ]

+//                      it.entries += createIntStatisticEntry => [

+//                              it.name = "NumericalSolverSolvingTime"

+//                              it.value = (strategy.numericSolver.solverSolvingProblem / 1000000) as int

+//                      ]

+//                      it.entries += createIntStatisticEntry => [

+//                              it.name = "NumericalSolverInterpretingSolution"

+//                              it.value = (strategy.numericSolver.solverSolution / 1000000) as int

+//                      ]

+//                      it.entries += createIntStatisticEntry => [

+//                              it.name = "NumericalSolverCachingTime"

+//                              it.value = (strategy.numericSolver.cachingTime / 1000000) as int

+//                      ]

+//                      it.entries += createIntStatisticEntry => [

+//                              it.name = "NumericalSolverCallNumber"

+//                              it.value = strategy.numericSolver.numberOfSolverCalls

+//                      ]

+//                      it.entries += createIntStatisticEntry => [

+//                              it.name = "NumericalSolverCachedAnswerNumber"

+//                              it.value = strategy.numericSolver.numberOfCachedSolverCalls

+//                      ]

+                        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) {

-                        return createInsuficientResourcesResult=>[

+

+                if (stoppedByTimeout) {

+                        return createInsuficientResourcesResult => [

                                 it.problem = problem

-                                it.resourceName="time"

-                                it.representation += strategy.solutionStoreWithCopy.solutions

+                                it.resourceName = "time"

+                                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.representation += strategy.solutionStoreWithCopy.solutions

+                                        it.trace = solutionCopier.getTraces(true)

+                                        it.representation += solutionCopier.getPartialInterpretations(true)

                                         it.statistics = statistics

                                 ]

                         }

                 }

         }

 

-    private def dispatch long runtime(NeighbourhoodBasedStateCoderFactory sc) {

-        sc.sumStatecoderRuntime

-    }

+        private def dispatch long runtime(AbstractNeighbourhoodBasedStateCoderFactory sc) {

+                sc.sumStatecoderRuntime

+        }

 

-    private def dispatch long runtime(IdentifierBasedStateCoderFactory sc) {

-        sc.sumStatecoderRuntime

-    }

+        private def dispatch long runtime(IdentifierBasedStateCoderFactory sc) {

+                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 10734859..628844de 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
@@ -5,21 +5,37 @@ import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasoner
 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicSolverConfiguration

 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.LinearTypeConstraintHint

+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.logic2viatra.patterns.UnitPropagationPatternGenerator

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualiser

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.CostObjectiveHint

+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

 

-public enum StateCoderStrategy {

-        Neighbourhood, NeighbourhoodWithEquivalence, IDBased, DefinedByDiversity

+enum StateCoderStrategy {

+        Neighbourhood,

+        PairwiseNeighbourhood,

+        NeighbourhoodWithEquivalence,

+        IDBased,

+        DefinedByDiversity

 }

 

-class ViatraReasonerConfiguration extends LogicSolverConfiguration{

-        //public var Iterable<PQuery> existingQueries

-        

+enum PunishSizeStrategy {

+        NONE,

+        SMALLER_IS_BETTER,

+        LARGER_IS_BETTER

+}

+

+class ViatraReasonerConfiguration extends LogicSolverConfiguration {

+        // public var Iterable<PQuery> existingQueries

         public var nameNewElements = false

         public var StateCoderStrategy stateCoderStrategy = StateCoderStrategy.Neighbourhood

         public var TypeInferenceMethod typeInferenceMethod = TypeInferenceMethod.PreliminaryAnalysis

@@ -27,7 +43,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.

@@ -41,22 +57,40 @@ 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.

          */

-         public var SearchSpaceConstraint searchSpaceConstraints = new SearchSpaceConstraint

+        public var SearchSpaceConstraint searchSpaceConstraints = new SearchSpaceConstraint

          

-         public var RealisticGuidance realisticGuidance = RealisticGuidance.Composite;

+        public var runIntermediateNumericalConsistencyChecks = true

+        

+        public var punishSize = PunishSizeStrategy.NONE

+        public var scopeWeight = 1

+        public var conaintmentWeight = 2

+        public var nonContainmentWeight = 1

+        public var unfinishedWFWeight = 1

+        public var calculateObjectCreationCosts = false

+        

+        public var RealisticGuidance realisticGuidance = RealisticGuidance.Composite;

          

          public var isWFOptional = false;

          

          public var allowMustViolations = false;

          

          public var String domain = '';

+        public var ScopePropagatorStrategy scopePropagatorStrategy = new ScopePropagatorStrategy.Polyhedral(

+                PolyhedralScopePropagatorConstraints.Relational, PolyhedralScopePropagatorSolver.Clp)

+//      public var ScopePropagatorStrategy scopePropagatorStrategy = ScopePropagatorStrategy.BasicTypeHierarchy

+        

+        public var List<LinearTypeConstraintHint> hints = newArrayList

+

+        public var List<CostObjectiveConfiguration> costObjectives = newArrayList

+        

+        public var List<UnitPropagationPatternGenerator> unitPropagationPatternGenerators = newArrayList

 }

 

-public class DiversityDescriptor {

+class DiversityDescriptor {

         public var ensureDiversity = false

         public static val FixPointRange = -1

         public var int range = FixPointRange

@@ -66,6 +100,23 @@ public class DiversityDescriptor {
         public var Set<RelationDeclaration> relevantRelations = null

 }

 

+class DebugConfiguration {

+        public var PartialInterpretationVisualiser partialInterpretatioVisualiser = null

+        public var partalInterpretationVisualisationFrequency = 1

+}

+

+class InternalConsistencyCheckerConfiguration {

+        public var LogicReasoner internalIncosnsitencyDetector = null

+        public var LogicSolverConfiguration internalInconsistencDetectorConfiguration = null

+        public var incternalConsistencyCheckingFrequency = 1

+}

+

+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

+}

+

 public enum RealisticGuidance{

         MPC,

         NodeActivity,

@@ -75,21 +126,16 @@ public enum RealisticGuidance{
         Composite_Without_Violations,

         Violations

 }

-

-public class DebugConfiguration {

-        public var logging = false

-        public var PartialInterpretationVisualiser partialInterpretatioVisualiser = null;

-        public var partalInterpretationVisualisationFrequency = 1

+class CostObjectiveConfiguration {

+        public var List<CostObjectiveElementConfiguration> elements = newArrayList

+        public var ObjectiveKind kind

+        public var ObjectiveThreshold threshold

+        public var boolean findExtremum

+        public var CostObjectiveHint hint

 }

 

-public class InternalConsistencyCheckerConfiguration {

-        public var LogicReasoner internalIncosnsitencyDetector = null

-        public var LogicSolverConfiguration internalInconsistencDetectorConfiguration = null

-        public var incternalConsistencyCheckingFrequency = 1

+class CostObjectiveElementConfiguration {

+        public var String patternQualifiedName

+        public var int weight

 }

 

-public 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
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ActivationSelector.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ActivationSelector.xtend
new file mode 100644
index 00000000..65f9814c
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ActivationSelector.xtend
@@ -0,0 +1,24 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse

+

+import java.util.ArrayList

+import java.util.Collection

+import java.util.Random

+

+abstract class ActivationSelector {

+        long runtime = 0

+        protected val Random r

+        new(Random r) {

+                this.r = r

+        }

+        

+        def randomizeActivationIDs(Collection<Object> activationIDs) {

+                val startTime = System.nanoTime

+                val res = internalRandomizationOfActivationIDs(activationIDs)

+                runtime+= System.nanoTime-startTime

+                return res

+        }

+        def protected ArrayList<Object> internalRandomizationOfActivationIDs(Collection<Object> activationIDs);

+        def getRuntime(){

+                return runtime

+        }

+}
\ 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/BalancedActivationSelector.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BalancedActivationSelector.xtend
new file mode 100644
index 00000000..2df9957b
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/BalancedActivationSelector.xtend
@@ -0,0 +1,51 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse

+

+import java.util.Collection

+import java.util.HashMap

+import java.util.Map

+import java.util.List

+import java.util.Random

+import java.util.ArrayList

+import java.util.LinkedList

+import java.util.Collections

+

+class BalancedActivationSelector extends ActivationSelector{

+        val Random r = new Random

+        

+        new(Random r) {

+                super(r)

+        }

+        

+        override protected internalRandomizationOfActivationIDs(Collection<Object> activationIDs) {

+                val Map<String,List<Object>> urns = new HashMap

+                val res = new ArrayList(activationIDs.size)

+                for(activationID : activationIDs) {

+                        val pair = activationID as Pair<String,? extends Object>

+                        val name = pair.key

+                        val selectedUrn = urns.get(name)

+                        if(selectedUrn!==null) {

+                                selectedUrn.add(activationID)

+                        } else {

+                                val collection = new LinkedList

+                                collection.add(activationID)

+                                urns.put(name,collection)

+                        }

+                }

+                

+                for(list:urns.values) {

+                        Collections.shuffle(list,r)

+                }

+                

+                while(!urns.empty) {

+                        val randomEntry = urns.entrySet.get(r.nextInt(urns.size))

+                        val list = randomEntry.value

+                        val removedLast = list.remove(list.size-1)

+                        res.add(removedLast)

+                        if(list.empty) {

+                                urns.remove(randomEntry.key)

+                        }

+                }

+                return res

+        }

+        

+}
\ 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/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 d9a1e54c..2940d12d 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,9 +9,7 @@
  *******************************************************************************/

 package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse;

 

-import java.util.ArrayList;

 import java.util.Arrays;

-import java.util.Collection;

 import java.util.Collections;

 import java.util.Comparator;

 import java.util.Iterator;

@@ -22,17 +20,16 @@ import java.util.Random;
 

 import org.apache.log4j.Level;

 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.IObjective;

 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.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;

@@ -40,11 +37,11 @@ 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.viatrasolver.logic2viatra.ModelGenerationMethod;

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.PartialInterpretation2Logic;

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation;

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualisation;

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualiser;

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ModelGenerationMethod;

 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration;

 import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace;

 

@@ -77,54 +74,72 @@ 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;

-        

+//      private Collection<ViatraQueryMatcher<? extends IPatternMatch>> matchers;

+        public ActivationSelector activationSelector = new EvenActivationSelector(random);

+        public ViatraReasonerSolutionSaver solutionSaver;

+        public NumericSolver numericSolver;

         // Statistics

         private int numberOfStatecoderFail = 0;

         private int numberOfPrintedModel = 0;

         private int numberOfSolverCalls = 0;

+        public long globalConstraintEvaluationTime = 0;

+        public long fitnessCalculationTime = 0;

+        

+        public long explorationStarted = 0;

 

         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;

         }

+        public long getForwardTime() {

+                return context.getDesignSpaceManager().getForwardTime();

+        }

+        public long getBacktrackingTime() {

+                return context.getDesignSpaceManager().getBacktrackingTime();

+        }

 

         @Override

         public void initStrategy(ThreadContext context) {

                 this.context = context;

                 this.solutionStore = context.getGlobalContext().getSolutionStore();

-                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);

-                }

+                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);

                 

-                this.solutionStoreWithCopy = new SolutionStoreWithCopy();

-                this.solutionStoreWithDiversityDescriptor = new SolutionStoreWithDiversityDescriptor(configuration.diversityRequirement);

-

+//              ViatraQueryEngine engine = context.getQueryEngine();

+//              matchers = new LinkedList<ViatraQueryMatcher<? extends IPatternMatch>>();

+//              for(IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> p : this.method.getAllPatterns()) {

+//                              ViatraQueryMatcher<? extends IPatternMatch> matcher = p.getMatcher(engine);

+//              }

+//              

                 final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper();

                 this.comparator = new Comparator<TrajectoryWithFitness>() {

                         @Override

@@ -138,23 +153,26 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
 

         @Override

         public void explore() {

-                if (!context.checkGlobalConstraints()) {

+                this.explorationStarted=System.nanoTime();

+                if (!checkGlobalConstraints()) {

                         logger.info("Global contraint is not satisifed in the first state. Terminate.");

                         return;

+                } else if(!numericSolver.maySatisfiable()) {

+                        logger.info("Numeric contraints are not satisifed in the first state. Terminate.");

+                        return;

                 }

                 if (configuration.searchSpaceConstraints.maxDepth == 0) {

                         logger.info("Maximal depth is reached in the initial solution. Terminate.");

                         return;

                 }

                 

-                final Fitness firstFittness = context.calculateFitness();

-                checkForSolution(firstFittness);

+                final Fitness firstFitness = calculateFitness();

+                checkForSolution(firstFitness);

                 

                 final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper();

                 final Object[] firstTrajectory = context.getTrajectory().toArray(new Object[0]);

-                TrajectoryWithFitness currentTrajectoryWithFittness = new TrajectoryWithFitness(firstTrajectory, firstFittness);

-                trajectoiresToExplore.add(currentTrajectoryWithFittness);

-                

+                TrajectoryWithFitness currentTrajectoryWithFitness = new TrajectoryWithFitness(firstTrajectory, firstFitness);

+                trajectoiresToExplore.add(currentTrajectoryWithFitness);

                 //if(configuration)

                 visualiseCurrentState();

 //              for(ViatraQueryMatcher<? extends IPatternMatch> matcher : matchers) {

@@ -168,22 +186,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;

 //                      }

@@ -193,32 +211,30 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
 

                         while (!isInterrupted && !configuration.progressMonitor.isCancelled() && iterator.hasNext()) {

                                 final Object nextActivation = iterator.next();

-//                              if (!iterator.hasNext()) {

-//                                      logger.debug("Last untraversed activation of the state.");

-//                                      trajectoiresToExplore.remove(currentTrajectoryWithFittness);

-//                              }

                                 logger.debug("Executing new activation: " + nextActivation);

                                 context.executeAcitvationId(nextActivation);

+                                method.getStatistics().incrementDecisionCount();

 

                                 visualiseCurrentState();

 //                              for(ViatraQueryMatcher<? extends IPatternMatch> matcher : matchers) {

-//                                      System.out.println(matcher.getPatternName());

-//                                      System.out.println("---------");

-//                                      for(IPatternMatch m : matcher.getAllMatches()) {

-//                                              System.out.println(m);

-//                                      }

-//                                      System.out.println("---------");

+//                                      int c = matcher.countMatches();

+//                                      if(c>=1) {

+//                                              System.out.println(c+ " " +matcher.getPatternName());

+//                                      }       

 //                              }

                                 

-                                boolean consistencyCheckResult = checkConsistency(currentTrajectoryWithFittness);

+                                boolean consistencyCheckResult = checkConsistency(currentTrajectoryWithFitness);

                                 if(consistencyCheckResult == true) { continue mainLoop; }

 

                                 if (context.isCurrentStateAlreadyTraversed()) {

                                         logger.info("The new state is already visited.");

                                         context.backtrack();

-                                } else if (!context.checkGlobalConstraints()) {

+                                } else if (!checkGlobalConstraints()) {

                                         logger.debug("Global contraint is not satisifed.");

                                         context.backtrack();

+                                } else if (!numericSolver.maySatisfiable()) {

+                                        logger.debug("Numeric constraints are not satisifed.");

+                                        context.backtrack();

                                 } else {

                                         final Fitness nextFitness = context.calculateFitness();

                                         checkForSolution(nextFitness);

@@ -228,59 +244,89 @@ 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,

-                                                        nextTrajectoryWithFittness.fitness);

+                                        int compare = objectiveComparatorHelper.compare(currentTrajectoryWithFitness.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);

-                        currentTrajectoryWithFittness = null;

+                        trajectoiresToExplore.remove(currentTrajectoryWithFitness);

+                        currentTrajectoryWithFitness = null;

 

                 }

                 logger.info("Interrupted.");

         }

 

+        private boolean checkGlobalConstraints() {

+                long start = System.nanoTime();

+                boolean result = context.checkGlobalConstraints();

+                globalConstraintEvaluationTime += System.nanoTime() - start;

+                return result;

+        }

+        

+        private Fitness calculateFitness() {

+                long start = System.nanoTime();

+                Fitness fitness = context.calculateFitness(); 

+                fitnessCalculationTime += System.nanoTime() - start;

+                return fitness;

+        }

+        

         private List<Object> selectActivation() {

                 List<Object> activationIds;

                 try {

-                        activationIds = new ArrayList<Object>(context.getUntraversedActivationIds());

-                        Collections.shuffle(activationIds);

+                        activationIds = this.activationSelector.randomizeActivationIDs(context.getUntraversedActivationIds());

                 } catch (NullPointerException e) {

+//                      logger.warn("Unexpected state code: " + context.getDesignSpaceManager().getCurrentState());

                         numberOfStatecoderFail++;

                         activationIds = Collections.emptyList();

                 }

                 return activationIds;

         }

 

-        private void checkForSolution(final Fitness fittness) {

-                if (fittness.isSatisifiesHardObjectives()) {

-                        if (solutionStoreWithDiversityDescriptor.isDifferent(context)) {

-                                solutionStoreWithCopy.newSolution(context);

-                                solutionStoreWithDiversityDescriptor.newSolution(context);

-                                solutionStore.newSolution(context);

-                                configuration.progressMonitor.workedModelFound(configuration.solutionScope.numberOfRequiredSolution);

-

-                                logger.debug("Found a solution.");

-                        }

-                }

+        private void checkForSolution(final Fitness fitness) {

+                solutionStore.newSolution(context);

+        }

+        

+        public List<String> times = new LinkedList<String>();

+        private void saveTimes() {

+                long forwardTime = context.getDesignSpaceManager().getForwardTime()/1000000;

+                long backtrackingTime = context.getDesignSpaceManager().getBacktrackingTime()/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;

+                long numericalSolverInterpreting = this.numericSolver.getSolverSolution()/1000000;

+                this.times.add(

+                        "(TransformationExecutionTime"+method.getStatistics().transformationExecutionTime/1000000+

+                        "|ForwardTime:"+forwardTime+

+                        "|Backtrackingtime:"+backtrackingTime+

+                        "|GlobalConstraintEvaluationTime:"+(globalConstraintEvaluationTime/1000000)+

+                        "|FitnessCalculationTime:"+(fitnessCalculationTime/1000000)+

+                        "|ActivationSelectionTime:"+activationSelection+

+                        "|SolutionCopyTime:"+solutionCopierTime+

+                        "|NumericalSolverSumTime:"+numericalSolverSumTime+

+                        "|NumericalSolverProblemFormingTime:"+numericalSolverProblemForming+

+                        "|NumericalSolverSolvingTime:"+numericalSolverSolving+

+                        "|NumericalSolverInterpretingSolution:"+numericalSolverInterpreting+")");

+                

         }

 

         @Override

@@ -309,7 +355,7 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                 } else {

                         return trajectoiresToExplore.element();

                 }

-        }       

+        }

 

 //      private void logCurrentStateMetric() {

 //      if(this.configuration.documentationLevel != DocumentationLevel.NONE || workspace == null) {

@@ -322,13 +368,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/EvenActivationSelector.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/EvenActivationSelector.xtend
new file mode 100644
index 00000000..82a5f32d
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/EvenActivationSelector.xtend
@@ -0,0 +1,20 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse

+

+import java.util.Random

+import java.util.Collection

+import java.util.Collections

+import java.util.ArrayList

+

+class EvenActivationSelector extends ActivationSelector {

+        

+        new(Random r) {

+                super(r)

+        }

+        

+        override protected internalRandomizationOfActivationIDs(Collection<Object> activationIDs) {

+                val toShuffle = new ArrayList<Object>(activationIDs);

+                Collections.shuffle(toShuffle);

+                return toShuffle

+        }

+        

+}
\ 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/HillClimbingOnRealisticMetricStrategyForModelGeneration.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/HillClimbingOnRealisticMetricStrategyForModelGeneration.java
index eb7df089..d9f84b36 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/HillClimbingOnRealisticMetricStrategyForModelGeneration.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/HillClimbingOnRealisticMetricStrategyForModelGeneration.java
@@ -16,6 +16,7 @@ import java.util.Random;
 import java.util.Set;
 
 import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy;
 import org.eclipse.viatra.dse.base.ThreadContext;
@@ -35,480 +36,540 @@ 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.viatrasolver.logic2viatra.ModelGenerationMethod;
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.PartialInterpretation2Logic;
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder.NeighbourhoodBasedPartialInterpretationStateCoder;
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualisation;
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualiser;
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ModelGenerationMethod;
 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.RealisticGuidance;
 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration;
 import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace;
 
 public class HillClimbingOnRealisticMetricStrategyForModelGeneration implements IStrategy {
         // Services and Configuration
-                private ThreadContext context;
-                private ReasonerWorkspace workspace;
-                private ViatraReasonerConfiguration configuration;
-                private ModelGenerationMethod method;
-                private PartialInterpretation2Logic partialInterpretation2Logic = new PartialInterpretation2Logic();
-                private Comparator<TrajectoryWithFitness> comparator;
-                private Logger logger = Logger.getLogger(IStrategy.class);
+        private ThreadContext context;
+        private ReasonerWorkspace workspace;
+        private ViatraReasonerConfiguration configuration;
+        private ModelGenerationMethod method;
+        private PartialInterpretation2Logic partialInterpretation2Logic = new PartialInterpretation2Logic();
+        private Comparator<TrajectoryWithFitness> comparator;
+        private Logger logger = Logger.getLogger(IStrategy.class);
+        public NumericSolver numericSolver = null;
+
+        // 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();
+        
+        // matchers for detecting the number of violations
+        private Collection<ViatraQueryMatcher<? extends IPatternMatch>> mustMatchers;
+        private Collection<ViatraQueryMatcher<? extends IPatternMatch>> mayMatchers;
+
+        // Encode the used activations of a particular state
+        private Map<Object, List<Object>> stateAndActivations;
+        private boolean allowMustViolation;
+        private Domain domain;
+        int targetSize;
+        public ActivationSelector activationSelector = new EvenActivationSelector(random);
+        // Statistics
+        private int numberOfStatecoderFail = 0;
+        private int numberOfPrintedModel = 0;
+        private int numberOfSolverCalls = 0;
+        private PartialInterpretationMetricDistance metricDistance; 
+        private double currentStateValue = Double.MAX_VALUE;
+        private double currentNodeTypeDistance = 1;
+        private int numNodesToGenerate = 0;
+        public long explorationStarted = 0;
+        public long globalConstraintEvaluationTime = 0;
+        public long fitnessCalculationTime = 0;
+        
+        public HillClimbingOnRealisticMetricStrategyForModelGeneration(
+                        ReasonerWorkspace workspace,
+                        ViatraReasonerConfiguration configuration,
+                        ModelGenerationMethod method)
+        {
+                this.workspace = workspace;
+                this.configuration = configuration;
+                this.method = method;
+        }
+        
+        public SolutionStoreWithCopy getSolutionStoreWithCopy() {
+                return solutionStoreWithCopy;
+        }
+        public SolutionStoreWithDiversityDescriptor getSolutionStoreWithDiversityDescriptor() {
+                return solutionStoreWithDiversityDescriptor;
+        }
+        public int getNumberOfStatecoderFail() {
+                return numberOfStatecoderFail;
+        }
+        
+        public long getForwardTime() {
+                return context.getDesignSpaceManager().getForwardTime();
+        }
+        public long getBacktrackingTime() {
+                return context.getDesignSpaceManager().getBacktrackingTime();
+        }
+
+        @Override
+        public void initStrategy(ThreadContext context) {
+                this.context = context;
+                this.solutionStore = context.getGlobalContext().getSolutionStore();
+                domain = Domain.valueOf(configuration.domain);
+
+                ViatraQueryEngine engine = context.getQueryEngine();
+//                      // TODO: visualisation
+                mustMatchers = new LinkedList<ViatraQueryMatcher<? extends IPatternMatch>>();
+                mayMatchers = new LinkedList<ViatraQueryMatcher<? extends IPatternMatch>>();
                 
-                // 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();
+                // manully restict the number of super types of one class
+                this.method.getInvalidWF().forEach(a ->{ 
+                        ViatraQueryMatcher<? extends IPatternMatch> matcher = a.getMatcher(engine);
+                        mustMatchers.add(matcher);
+                });
                 
-                // matchers for detecting the number of violations
-                private Collection<ViatraQueryMatcher<? extends IPatternMatch>> mustMatchers;
-                private Collection<ViatraQueryMatcher<? extends IPatternMatch>> mayMatchers;
+                this.method.getUnfinishedWF().forEach(a ->{ 
+                        ViatraQueryMatcher<? extends IPatternMatch> matcher = a.getMatcher(engine);
+                        mayMatchers.add(matcher);
+                });
         
-                // Encode the used activations of a particular state
-                private Map<Object, List<Object>> stateAndActivations;
-                private boolean allowMustViolation;
-                private Domain domain;
-                int targetSize;
-
-                // Statistics
-                private int numberOfStatecoderFail = 0;
-                private int numberOfPrintedModel = 0;
-                private int numberOfSolverCalls = 0;
-                private PartialInterpretationMetricDistance metricDistance; 
-                private double currentStateValue = Double.MAX_VALUE;
-                private double currentNodeTypeDistance = 1;
-                private int numNodesToGenerate = 0;
                 
-                public HillClimbingOnRealisticMetricStrategyForModelGeneration(
-                                ReasonerWorkspace workspace,
-                                ViatraReasonerConfiguration configuration,
-                                ModelGenerationMethod method)
-                {
-                        this.workspace = workspace;
-                        this.configuration = configuration;
-                        this.method = method;
-                }
+                //set up comparator
+                final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper();
+                this.comparator = new Comparator<TrajectoryWithFitness>() {
+                        @Override
+                        public int compare(TrajectoryWithFitness o1, TrajectoryWithFitness o2) {
+                                return objectiveComparatorHelper.compare(o2.fitness, o1.fitness);
+                        }
+                };
                 
-                public SolutionStoreWithCopy getSolutionStoreWithCopy() {
-                        return solutionStoreWithCopy;
-                }
-                public SolutionStoreWithDiversityDescriptor getSolutionStoreWithDiversityDescriptor() {
-                        return solutionStoreWithDiversityDescriptor;
+                this.solutionStoreWithCopy = new SolutionStoreWithCopy();
+                this.solutionStoreWithDiversityDescriptor = new SolutionStoreWithDiversityDescriptor(configuration.diversityRequirement);
+                
+                trajectoiresToExplore = new PriorityQueue<TrajectoryWithFitness>(11, comparator);
+                stateAndActivations = new HashMap<Object, List<Object>>();
+                metricDistance = new PartialInterpretationMetricDistance(domain);
+                
+                //set whether allows must violations during the realistic generation
+                allowMustViolation = configuration.allowMustViolations;
+                targetSize = configuration.typeScopes.maxNewElements + 2;
+                //this.numericSolver = new NumericSolver(method, this.configuration.runIntermediateNumericalConsistencyChecks, false);
+        }
+
+        @Override
+        public void explore() {
+                this.explorationStarted=System.nanoTime();
+                if (!checkGlobalConstraints()) {
+                        logger.info("Global contraint is not satisifed in the first state. Terminate.");
+                        return;
                 }
-                public int getNumberOfStatecoderFail() {
-                        return numberOfStatecoderFail;
+                if (configuration.searchSpaceConstraints.maxDepth == 0) {
+                        logger.info("Maximal depth is reached in the initial solution. Terminate.");
+                        return;
                 }
-
-                @Override
-                public void initStrategy(ThreadContext context) {
-                        this.context = context;
-                        this.solutionStore = context.getGlobalContext().getSolutionStore();
-                        domain = Domain.valueOf(configuration.domain);
-
-                        ViatraQueryEngine engine = context.getQueryEngine();
-//                      // TODO: visualisation
-                        mustMatchers = new LinkedList<ViatraQueryMatcher<? extends IPatternMatch>>();
-                        mayMatchers = new LinkedList<ViatraQueryMatcher<? extends IPatternMatch>>();
-                        
-                        // manully restict the number of super types of one class
-                        this.method.getInvalidWF().forEach(a ->{ 
-                                ViatraQueryMatcher<? extends IPatternMatch> matcher = a.getMatcher(engine);
-                                mustMatchers.add(matcher);
-                        });
-                        
-                        this.method.getUnfinishedWF().forEach(a ->{ 
-                                ViatraQueryMatcher<? extends IPatternMatch> matcher = a.getMatcher(engine);
-                                mayMatchers.add(matcher);
-                        });
                 
-                        
-                        //set up comparator
-                        final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper();
-                        this.comparator = new Comparator<TrajectoryWithFitness>() {
-                                @Override
-                                public int compare(TrajectoryWithFitness o1, TrajectoryWithFitness o2) {
-                                        return objectiveComparatorHelper.compare(o2.fitness, o1.fitness);
+                final Fitness firstFittness = context.calculateFitness();
+                
+                //final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper();
+                final Object[] firstTrajectory = context.getTrajectory().toArray(new Object[0]);
+                TrajectoryWithFitness currentTrajectoryWithFittness = new TrajectoryWithFitness(firstTrajectory, firstFittness);
+                trajectoiresToExplore.add(currentTrajectoryWithFittness);
+                Object lastState = null;
+                
+                //if(configuration)
+                visualiseCurrentState();
+                // the two is the True and False node generated at the beginning of the generation
+                int count = 0;
+                mainLoop: while (!isInterrupted && !configuration.progressMonitor.isCancelled()) {
+
+                        if (currentTrajectoryWithFittness == null) {
+                                if (trajectoiresToExplore.isEmpty()) {
+                                        logger.debug("State space is fully traversed.");
+                                        return;
+                                } else {
+                                        currentTrajectoryWithFittness = selectState();
+                                        if (logger.isDebugEnabled()) {
+                                                logger.debug("Current trajectory: " + Arrays.toString(context.getTrajectory().toArray()));
+                                                logger.debug("New trajectory is chosen: " + currentTrajectoryWithFittness);
+                                        }
+                                        context.getDesignSpaceManager().executeTrajectoryWithMinimalBacktrackWithoutStateCoding(currentTrajectoryWithFittness.trajectory);
+                                        
+                                        // reset the regression for this trajectory
+                                        metricDistance.getLinearModel().resetRegression(context.getCurrentStateId());
                                 }
-                        };
+                        }
                         
-                        this.solutionStoreWithCopy = new SolutionStoreWithCopy();
-                        this.solutionStoreWithDiversityDescriptor = new SolutionStoreWithDiversityDescriptor(configuration.diversityRequirement);
+                        List<Object> activationIds = selectActivation();
+                        PartialInterpretation model = (PartialInterpretation) context.getModel();
+                        System.out.println(model.getNewElements().size());
+                        System.out.println("# violations: " + getNumberOfViolations(mayMatchers));
                         
-                        trajectoiresToExplore = new PriorityQueue<TrajectoryWithFitness>(11, comparator);
-                        stateAndActivations = new HashMap<Object, List<Object>>();
-                        metricDistance = new PartialInterpretationMetricDistance(domain);
+                        Map<Object, Double> valueMap = new HashMap<Object,Double>();
                         
-                        //set whether allows must violations during the realistic generation
-                        allowMustViolation = configuration.allowMustViolations;
-                        targetSize = configuration.typeScopes.maxNewElements + 2;
-                }
+                        //init epsilon and draw
+                        MetricDistanceGroup heuristics =  metricDistance.calculateMetricDistanceKS(model);
 
-                @Override
-                public void explore() {
-                        if (!context.checkGlobalConstraints()) {
-                                logger.info("Global contraint is not satisifed in the first state. Terminate.");
-                                return;
-                        }
-                        if (configuration.searchSpaceConstraints.maxDepth == 0) {
-                                logger.info("Maximal depth is reached in the initial solution. Terminate.");
-                                return;
+                        if(!stateAndActivations.containsKey(context.getCurrentStateId())) {
+                                stateAndActivations.put(context.getCurrentStateId(), new ArrayList<Object>());
                         }
                         
-                        final Fitness firstFittness = context.calculateFitness();
-                        
-                        //final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper();
-                        final Object[] firstTrajectory = context.getTrajectory().toArray(new Object[0]);
-                        TrajectoryWithFitness currentTrajectoryWithFittness = new TrajectoryWithFitness(firstTrajectory, firstFittness);
-                        trajectoiresToExplore.add(currentTrajectoryWithFittness);
-                        Object lastState = null;
-                        
-                        //if(configuration)
-                        visualiseCurrentState();
-                        // the two is the True and False node generated at the beginning of the generation
-                        int count = 0;
-                        mainLoop: while (!isInterrupted && !configuration.progressMonitor.isCancelled()) {
+                        // calculate values for epsilon greedy
+                        double epsilon = 1.0/count;
+                        double draw = Math.random();
+                        count++;
+                        this.currentNodeTypeDistance = heuristics.getNodeTypeDistance();
+                        numNodesToGenerate = model.getMaxNewElements();
+                        System.out.println("NA distance: " + heuristics.getNADistance());       
+                        System.out.println("MPC distance: " + heuristics.getMPCDistance());     
+                        System.out.println("Out degree distance:" + heuristics.getOutDegreeDistance()); 
+                        System.out.println("NodeType :" + currentNodeTypeDistance);     
 
-                                if (currentTrajectoryWithFittness == null) {
-                                        if (trajectoiresToExplore.isEmpty()) {
-                                                logger.debug("State space is fully traversed.");
-                                                return;
-                                        } else {
-                                                currentTrajectoryWithFittness = selectState();
-                                                if (logger.isDebugEnabled()) {
-                                                        logger.debug("Current trajectory: " + Arrays.toString(context.getTrajectory().toArray()));
-                                                        logger.debug("New trajectory is chosen: " + currentTrajectoryWithFittness);
-                                                }
-                                                context.getDesignSpaceManager().executeTrajectoryWithMinimalBacktrackWithoutStateCoding(currentTrajectoryWithFittness.trajectory);
-                                                
-                                                // reset the regression for this trajectory
-                                                metricDistance.getLinearModel().resetRegression(context.getCurrentStateId());
-                                        }
-                                }
-                                
-                                List<Object> activationIds = selectActivation();
-                                PartialInterpretation model = (PartialInterpretation) context.getModel();
-//                              System.out.println(model.getNewElements().size());
-//                              System.out.println("# violations: " + getNumberOfViolations(mayMatchers));
-                                
-                                Map<Object, Double> valueMap = new HashMap<Object,Double>();
-                                
-                                //init epsilon and draw
-                                MetricDistanceGroup heuristics =  metricDistance.calculateMetricDistanceKS(model);
 
-                                if(!stateAndActivations.containsKey(context.getCurrentStateId())) {
-                                        stateAndActivations.put(context.getCurrentStateId(), new ArrayList<Object>());
-                                }
+                        //TODO: the number of activations to be checked should be configurasble
+                        if(activationIds.size() > 50) {
+                                activationIds = activationIds.subList(0, 50);
+                        }
+                        
+                        valueMap = sortWithWeight(activationIds);
+                        lastState = context.getCurrentStateId();
+                        while (!isInterrupted && !configuration.progressMonitor.isCancelled() && activationIds.size() > 0) {
+                                final Object nextActivation = drawWithEpsilonProbabilty(activationIds, valueMap, epsilon, draw);
+                                                                        
+                                stateAndActivations.get(context.getCurrentStateId()).add(nextActivation);
+                                logger.debug("Executing new activation: " + nextActivation);
+                                context.executeAcitvationId(nextActivation);
+                                visualiseCurrentState();
+                                boolean consistencyCheckResult = checkConsistency(currentTrajectoryWithFittness);
+                                if(consistencyCheckResult == true) { continue mainLoop; }
                                 
-                                // calculate values for epsilon greedy
-                                double epsilon = 1.0/count;
-                                double draw = Math.random();
-                                count++;
-                                this.currentNodeTypeDistance = heuristics.getNodeTypeDistance();
-                                numNodesToGenerate = model.getMaxNewElements();
-//                              System.out.println("NA distance: " + heuristics.getNADistance());       
-//                              System.out.println("MPC distance: " + heuristics.getMPCDistance());     
-//                              System.out.println("Out degree distance:" + heuristics.getOutDegreeDistance()); 
-//                              System.out.println("NodeType :" + currentNodeTypeDistance);     
-
-
-                                //TODO: the number of activations to be checked should be configurasble
-                                if(activationIds.size() > 50) {
-                                        activationIds = activationIds.subList(0, 50);
-                                }
+//                              if (context.isCurrentStateAlreadyTraversed()) {
+//                                      logger.info("The new state is already visited.");
+//                                      context.backtrack();
+//                              } else if (!checkGlobalConstraints()) {
+//                                      logger.debug("Global contraint is not satisifed.");
+//                                      context.backtrack();
+//                              } 
                                 
-                                valueMap = sortWithWeight(activationIds);
-                                lastState = context.getCurrentStateId();
-                                while (!isInterrupted && !configuration.progressMonitor.isCancelled() && activationIds.size() > 0) {
-                                        final Object nextActivation = drawWithEpsilonProbabilty(activationIds, valueMap, epsilon, draw);
-                                                                                
-                                        stateAndActivations.get(context.getCurrentStateId()).add(nextActivation);
-                                        logger.debug("Executing new activation: " + nextActivation);
-                                        context.executeAcitvationId(nextActivation);
-                                        visualiseCurrentState();
-                                        boolean consistencyCheckResult = checkConsistency(currentTrajectoryWithFittness);
-                                        if(consistencyCheckResult == true) { continue mainLoop; }
-                                        
-                                        int currentSize = model.getNewElements().size();
-                                        int targetDiff = targetSize - currentSize;
-                                        boolean shouldFinish = currentSize >= targetSize;
+                                int currentSize = model.getNewElements().size();
+                                int targetDiff = targetSize - currentSize;
+                                boolean shouldFinish = currentSize >= targetSize;
+                                
+                                // does not allow must violations
+                                if((getNumberOfViolations(mustMatchers) > 0|| getNumberOfViolations(mayMatchers) > targetDiff) && !allowMustViolation && !shouldFinish) {
+                                        context.backtrack();
+                                }else {
+                                        final Fitness nextFitness = context.calculateFitness();
                                         
-                                        // does not allow must violations
-                                        if((getNumberOfViolations(mustMatchers) > 0|| getNumberOfViolations(mayMatchers) > targetDiff) && !allowMustViolation && !shouldFinish) {
+                                        // the only hard objectives are configured in the config file
+                                        checkForSolution(nextFitness);
+                        
+                                        if (context.getDepth() > configuration.searchSpaceConstraints.maxDepth) {
+                                                logger.debug("Reached max depth.");
                                                 context.backtrack();
-                                        }else {
-                                                final Fitness nextFitness = context.calculateFitness();
-                                                
-                                                // the only hard objectives are configured in the config file
-                                                checkForSolution(nextFitness);
-                                
-                                                if (context.getDepth() > configuration.searchSpaceConstraints.maxDepth) {
-                                                        logger.debug("Reached max depth.");
-                                                        context.backtrack();
-                                                        continue;
-                                                }
-                                                
-                                                //Record value for current trajectory
-                                                TrajectoryWithFitness nextTrajectoryWithFittness = new TrajectoryWithFitness(
-                                                                context.getTrajectory().toArray(), nextFitness);
-                                                int nodeSize = ((PartialInterpretation) context.getModel()).getNewElements().size();
-                                                int violation = getNumberOfViolations(mayMatchers);
-                                                double currentValue = calculateCurrentStateValue(nodeSize, violation);
-                                                metricDistance.getLinearModel().feedData(context.getCurrentStateId(), metricDistance.calculateFeature(nodeSize, violation), currentValue, lastState);
-                                                trajectoiresToExplore.add(nextTrajectoryWithFittness);
-                                                currentStateValue = currentValue;
-                                                //Currently, just go to the next state without considering the value of trajectory
-                                                currentTrajectoryWithFittness = nextTrajectoryWithFittness;
-                                                continue mainLoop;
-
+                                                continue;
                                         }
+                                        
+                                        //Record value for current trajectory
+                                        TrajectoryWithFitness nextTrajectoryWithFittness = new TrajectoryWithFitness(
+                                                        context.getTrajectory().toArray(), nextFitness);
+                                        int nodeSize = ((PartialInterpretation) context.getModel()).getNewElements().size();
+                                        int violation = getNumberOfViolations(mayMatchers);
+                                        double currentValue = calculateCurrentStateValue(nodeSize, violation);
+                                        metricDistance.getLinearModel().feedData(context.getCurrentStateId(), metricDistance.calculateFeature(nodeSize, violation), currentValue, lastState);
+                                        trajectoiresToExplore.add(nextTrajectoryWithFittness);
+                                        currentStateValue = currentValue;
+                                        //Currently, just go to the next state without considering the value of trajectory
+                                        currentTrajectoryWithFittness = nextTrajectoryWithFittness;
+                                        continue mainLoop;
+
                                 }
-                                logger.debug("State is fully traversed.");
-                                trajectoiresToExplore.remove(currentTrajectoryWithFittness);
-                                currentTrajectoryWithFittness = null;
-                                context.backtrack();
                         }
-                        logger.info("Interrupted.");
+                        logger.debug("State is fully traversed.");
+                        trajectoiresToExplore.remove(currentTrajectoryWithFittness);
+                        currentTrajectoryWithFittness = null;
+                        context.backtrack();
                 }
+                logger.info("Interrupted.");
+        }
 
-                /**
-                 *
-                 * @param activationIds
-                 * @return: activation to value map
-                 */
-                private Map<Object, Double> sortWithWeight(List<Object> activationIds){
-                        Map<Object, Double> valueMap = new HashMap<Object, Double>();
-                        Object currentId = context.getCurrentStateId();
-                        // check for next states
-                        for(Object id : activationIds) {
-                                context.executeAcitvationId(id);
-                                int violation = getNumberOfViolations(mayMatchers);
+        private boolean checkGlobalConstraints() {
+                long start = System.nanoTime();
+                boolean result = context.checkGlobalConstraints();
+                globalConstraintEvaluationTime += System.nanoTime() - start;
+                return result;
+        }
+        
+        private Fitness calculateFitness() {
+                long start = System.nanoTime();
+                Fitness fitness = context.calculateFitness(); 
+                fitnessCalculationTime += System.nanoTime() - start;
+                return fitness;
+        }
+        
+        /**
+         *
+         * @param activationIds
+         * @return: activation to value map
+         */
+        private Map<Object, Double> sortWithWeight(List<Object> activationIds){
+                Map<Object, Double> valueMap = new HashMap<Object, Double>();
+                Object currentId = context.getCurrentStateId();
+                // check for next states
+                for(Object id : activationIds) {
+                        context.executeAcitvationId(id);
+                        int violation = getNumberOfViolations(mayMatchers);
 
-                                if(!allowMustViolation && getNumberOfViolations(mustMatchers) > 0) {
-                                        valueMap.put(id, Double.MAX_VALUE);
-                                        stateAndActivations.get(currentId).add(id);
-                                }else {
-                                        valueMap.put(id, calculateFutureStateValue(violation));
-                                }
-                                        
-                                
-                                
-                                context.backtrack();
+                        if(!allowMustViolation && getNumberOfViolations(mustMatchers) > 0) {
+                                valueMap.put(id, Double.MAX_VALUE);
+                                stateAndActivations.get(currentId).add(id);
+                        }else {
+                                valueMap.put(id, calculateFutureStateValue(violation));
                         }
+                                
+                        
                         
-                        //remove all the elements having large distance
-                        Collections.sort(activationIds, Comparator.comparing(li -> valueMap.get(li)));
-                        return valueMap;
+                        context.backtrack();
                 }
                 
-                private double calculateFutureStateValue(int violation) {
-                        long start = System.nanoTime();
-                        int nodeSize = ((PartialInterpretation) context.getModel()).getNewElements().size();
-                        double currentValue = calculateCurrentStateValue(nodeSize,violation);
-                        double[] toPredict = metricDistance.calculateFeature(100, violation);
-                        if(Math.abs(currentValue - currentStateValue) < 0.001) {
-                                this.method.getStatistics().addMetricCalculationTime(System.nanoTime() - start);
-                                return Double.MAX_VALUE;
-                        }
-                        try {
-                                this.method.getStatistics().addMetricCalculationTime(System.nanoTime() - start);
-                                return metricDistance.getLinearModel().getPredictionForNextDataSample(metricDistance.calculateFeature(nodeSize, violation), currentValue, toPredict);
-                        }catch(IllegalArgumentException e) {
-                                this.method.getStatistics().addMetricCalculationTime(System.nanoTime() - start);
-                                return currentValue;
-                        }
-
+                //remove all the elements having large distance
+                Collections.sort(activationIds, Comparator.comparing(li -> valueMap.get(li)));
+                return valueMap;
+        }
+        
+        private double calculateFutureStateValue(int violation) {
+                long start = System.nanoTime();
+                int nodeSize = ((PartialInterpretation) context.getModel()).getNewElements().size();
+                double currentValue = calculateCurrentStateValue(nodeSize,violation);
+                double[] toPredict = metricDistance.calculateFeature(100, violation);
+                if(Math.abs(currentValue - currentStateValue) < 0.001) {
+                        this.method.getStatistics().addMetricCalculationTime(System.nanoTime() - start);
+                        return Double.MAX_VALUE;
+                }
+                try {
+                        this.method.getStatistics().addMetricCalculationTime(System.nanoTime() - start);
+                        return metricDistance.getLinearModel().getPredictionForNextDataSample(metricDistance.calculateFeature(nodeSize, violation), currentValue, toPredict);
+                }catch(IllegalArgumentException e) {
+                        this.method.getStatistics().addMetricCalculationTime(System.nanoTime() - start);
+                        return currentValue;
                 }
-                private double calculateCurrentStateValue(int factor, int violation) {
-                        PartialInterpretation model = (PartialInterpretation) context.getModel();
-                        MetricDistanceGroup g = metricDistance.calculateMetricDistanceKS(model);
-                        if(configuration.realisticGuidance == RealisticGuidance.MPC) {
-                                return g.getMPCDistance();
-                        }else if(configuration.realisticGuidance == RealisticGuidance.NodeActivity) {
-                                return g.getNADistance();
-                        }else if(configuration.realisticGuidance == RealisticGuidance.OutDegree) {
-                                return g.getOutDegreeDistance();
-                        }else if(configuration.realisticGuidance == RealisticGuidance.NodeType) {
-                                return g.getNodeTypeDistance();
-                        }else if(configuration.realisticGuidance == RealisticGuidance.Composite) {
-                                double consistenceWeights = 5 * factor / (configuration.typeScopes.maxNewElements + 2) * (1- 1.0/(1+violation));
-                                if(domain == Domain.Yakindumm) {
-                                        double unfinishFactor = 50 * (1 - (double)factor / targetSize);
-                                        double nodeTypeFactor = g.getNodeTypeDistance();
-                                        double normalFactor = 5;
-                                        if(currentNodeTypeDistance <= 0.05 || numNodesToGenerate == 1) {
-                                                nodeTypeFactor = 0;
-                                                normalFactor = 100;
-                                                unfinishFactor = 0; 
-                                        }
-                                        
-                                        return 100*(nodeTypeFactor) + normalFactor*(2*g.getNADistance() + g.getMPCDistance() + 2*g.getOutDegreeDistance()) + normalFactor / 5*consistenceWeights + unfinishFactor;
-                                }else if (domain == Domain.Ecore) {
-                                        double unfinishFactor = 100 * (1 - (double)factor / targetSize);
-                                        double nodeTypeFactor = g.getNodeTypeDistance();
-                                        double normalFactor = 5;
-                                        if(currentNodeTypeDistance <= 0.12 || numNodesToGenerate == 1) {
-                                                nodeTypeFactor = 0;
-                                                normalFactor = 100;
-                                                unfinishFactor *= 0.5; 
-                                        }
-                                        
-                                        return 100*(nodeTypeFactor) + normalFactor*(2*g.getNADistance() + g.getMPCDistance() + 2*g.getOutDegreeDistance()) + normalFactor / 5*consistenceWeights + unfinishFactor;
-                                }else {
-                                        double unfinishFactor = context.calculateFitness().get("CompositeUnfinishednessObjective");
-                                        double nodeTypeFactor = g.getNodeTypeDistance();
-                                        double normalFactor = 5;
-                                        if(currentNodeTypeDistance <= 0.05 || numNodesToGenerate == 1) {
-                                                nodeTypeFactor = 0;
-                                                normalFactor = 100;
-                                                //unfinishFactor *= 0.5; 
-                                        }
-                                        
-                                        return 100*(nodeTypeFactor) + normalFactor*(2*g.getNADistance() + 2*g.getMPCDistance() + 2*g.getOutDegreeDistance()) + normalFactor / 5*consistenceWeights + unfinishFactor;
-                                }
 
-                        }else if(configuration.realisticGuidance == RealisticGuidance.Composite_Without_Violations) {
-                                if(domain == Domain.Yakindumm) {
-                                        double unfinishFactor = 50 * (1 - (double)factor / targetSize);
-                                        double nodeTypeFactor = g.getNodeTypeDistance();
-                                        double normalFactor = 5;
-                                        if(currentNodeTypeDistance <= 0.05 || numNodesToGenerate == 1) {
-                                                nodeTypeFactor = 0;
-                                                normalFactor = 100;
-                                                unfinishFactor = 0; 
-                                        }
-                                        
-                                        return 100*(nodeTypeFactor) + normalFactor*(2*g.getNADistance() + g.getMPCDistance() + 2*g.getOutDegreeDistance()) + unfinishFactor;
-                                }else if (domain == Domain.Github) {
-                                        double unfinishFactor = 100 * (1 - (double)factor / targetSize);
-                                        double nodeTypeFactor = g.getNodeTypeDistance();
-                                        double normalFactor = 5;
-                                        if(currentNodeTypeDistance <= 0.12 || numNodesToGenerate == 1) {
-                                                nodeTypeFactor = 0;
-                                                normalFactor = 100;
-                                                unfinishFactor *= 0.5; 
-                                        }
-                                        
-                                        return 100*(nodeTypeFactor) + normalFactor*(2*g.getNADistance() + g.getMPCDistance() + 2*g.getOutDegreeDistance()) + unfinishFactor;
-                                } else {
-                                        double unfinishFactor = 100 * (1 - (double)factor / targetSize);
-                                        double nodeTypeFactor = g.getNodeTypeDistance();
-                                        double normalFactor = 5;
-                                        if(currentNodeTypeDistance <= 0.20 || numNodesToGenerate == 1) {
-                                                nodeTypeFactor = 0;
-                                                normalFactor = 100;
-                                                unfinishFactor *= 0.5; 
-                                        }
-                                        
-                                        return 100*(nodeTypeFactor) + normalFactor*(2*g.getNADistance() + g.getMPCDistance() + 2*g.getOutDegreeDistance()) + unfinishFactor;
+        }
+        private double calculateCurrentStateValue(int factor, int violation) {
+                PartialInterpretation model = (PartialInterpretation) context.getModel();
+                MetricDistanceGroup g = metricDistance.calculateMetricDistanceKS(model);
+                if(configuration.realisticGuidance == RealisticGuidance.MPC) {
+                        return g.getMPCDistance();
+                }else if(configuration.realisticGuidance == RealisticGuidance.NodeActivity) {
+                        return g.getNADistance();
+                }else if(configuration.realisticGuidance == RealisticGuidance.OutDegree) {
+                        return g.getOutDegreeDistance();
+                }else if(configuration.realisticGuidance == RealisticGuidance.NodeType) {
+                        return g.getNodeTypeDistance();
+                }else if(configuration.realisticGuidance == RealisticGuidance.Composite) {
+                        double consistenceWeights = 5 * factor / (configuration.typeScopes.maxNewElements + 2) * (1- 1.0/(1+violation));
+                        if(domain == Domain.Yakindumm) {
+                                double unfinishFactor = 50 * (1 - (double)factor / targetSize);
+                                double nodeTypeFactor = g.getNodeTypeDistance();
+                                double normalFactor = 5;
+                                if(currentNodeTypeDistance <= 0.05 || numNodesToGenerate == 1) {
+                                        nodeTypeFactor = 0;
+                                        normalFactor = 100;
+                                        unfinishFactor = 0; 
                                 }
+                                
+                                return 100*(nodeTypeFactor) + normalFactor*(2*g.getNADistance() + g.getMPCDistance() + 2*g.getOutDegreeDistance()) + normalFactor / 5*consistenceWeights + unfinishFactor;
+                        }else if (domain == Domain.Ecore) {
+                                double unfinishFactor = 100 * (1 - (double)factor / targetSize);
+                                double nodeTypeFactor = g.getNodeTypeDistance();
+                                double normalFactor = 5;
+                                if(currentNodeTypeDistance <= 0.12 || numNodesToGenerate == 1) {
+                                        nodeTypeFactor = 0;
+                                        normalFactor = 100;
+                                        unfinishFactor *= 0.5; 
+                                }
+                                
+                                return 100*(nodeTypeFactor) + normalFactor*(2*g.getNADistance() + g.getMPCDistance() + 2*g.getOutDegreeDistance()) + normalFactor / 5*consistenceWeights + unfinishFactor;
                         }else {
-                                return violation;
-                        }
-                }
-                
-                private int getNumberOfViolations(Collection<ViatraQueryMatcher<? extends IPatternMatch>> matchers) {
-                        int violations = matchers.stream().mapToInt(m -> m.countMatches()).sum();
-                        
-                        return violations;
-                }
-                
-                // Modified epsilon greedy choose for action based on value function
-                // with probability epsilon, choose the state with probability based on the weight
-                // with probability 1 - epsilon, choose the best state
-                // epsilon should decay w.r.t. time
-                private Object drawWithEpsilonProbabilty(List<Object> activationIds, Map<Object, Double> valueMap, double epsilon, double currentDraw) {
-                        if(activationIds.size() <= 0) {
-                                return null;
+                                double unfinishFactor = context.calculateFitness().get("CompositeUnfinishednessObjective");
+                                double nodeTypeFactor = g.getNodeTypeDistance();
+                                double normalFactor = 5;
+                                if(currentNodeTypeDistance <= 0.05 || numNodesToGenerate == 1) {
+                                        nodeTypeFactor = 0;
+                                        normalFactor = 100;
+                                        //unfinishFactor *= 0.5; 
+                                }
+                                
+                                return 100*(nodeTypeFactor) + normalFactor*(2*g.getNADistance() + 2*g.getMPCDistance() + 2*g.getOutDegreeDistance()) + normalFactor / 5*consistenceWeights + unfinishFactor;
                         }
-                        
-                        // if epsilon is smaller than current draw, return greedy choice 
-                        if(epsilon < currentDraw) {
-                                return activationIds.remove(0);
-                        }else {
-                                //else return draw with probability of the weights
-                                //find the sum of all 1-weights: the smaller the better
-                                double sum = valueMap.values().stream().mapToDouble(d->1).sum();
-                                double rand = Math.random() * sum;
-                                double iterator = 0.0;
-                                Object idToReturn = null;
+
+                }else if(configuration.realisticGuidance == RealisticGuidance.Composite_Without_Violations) {
+                        if(domain == Domain.Yakindumm) {
+                                double unfinishFactor = 50 * (1 - (double)factor / targetSize);
+                                double nodeTypeFactor = g.getNodeTypeDistance();
+                                double normalFactor = 5;
+                                if(currentNodeTypeDistance <= 0.05 || numNodesToGenerate == 1) {
+                                        nodeTypeFactor = 0;
+                                        normalFactor = 100;
+                                        unfinishFactor = 0; 
+                                }
                                 
-                                // draw an item with probability
-                                for(Object o : valueMap.keySet()) {
-                                        iterator += (1);
-                                        if(rand < iterator) {
-                                                idToReturn = o;
-                                                break;
-                                        }
+                                return 100*(nodeTypeFactor) + normalFactor*(2*g.getNADistance() + g.getMPCDistance() + 2*g.getOutDegreeDistance()) + unfinishFactor;
+                        }else if (domain == Domain.Github) {
+                                double unfinishFactor = 100 * (1 - (double)factor / targetSize);
+                                double nodeTypeFactor = g.getNodeTypeDistance();
+                                double normalFactor = 5;
+                                if(currentNodeTypeDistance <= 0.12 || numNodesToGenerate == 1) {
+                                        nodeTypeFactor = 0;
+                                        normalFactor = 100;
+                                        unfinishFactor *= 0.5; 
+                                }
+                                
+                                return 100*(nodeTypeFactor) + normalFactor*(2*g.getNADistance() + g.getMPCDistance() + 2*g.getOutDegreeDistance()) + unfinishFactor;
+                        } else {
+                                double unfinishFactor = 100 * (1 - (double)factor / targetSize);
+                                double nodeTypeFactor = g.getNodeTypeDistance();
+                                double normalFactor = 5;
+                                if(currentNodeTypeDistance <= 0.20 || numNodesToGenerate == 1) {
+                                        nodeTypeFactor = 0;
+                                        normalFactor = 100;
+                                        unfinishFactor *= 0.5; 
                                 }
                                 
-                                //delete the item from the list
-                                activationIds.remove(idToReturn);
-                                valueMap.remove(idToReturn);
-                                return idToReturn;
+                                return 100*(nodeTypeFactor) + normalFactor*(2*g.getNADistance() + g.getMPCDistance() + 2*g.getOutDegreeDistance()) + unfinishFactor;
                         }
+                }else {
+                        return violation;
                 }
+        }
+        
+        private int getNumberOfViolations(Collection<ViatraQueryMatcher<? extends IPatternMatch>> matchers) {
+                int violations = matchers.stream().mapToInt(m -> m.countMatches()).sum();
                 
-                private List<Object> selectActivation() {
-                        List<Object> activationIds;
-                        try {
-                                activationIds = new ArrayList<Object>(context.getCurrentActivationIds());
-                                if(stateAndActivations.containsKey(context.getCurrentStateId())) {
-                                        activationIds.removeAll(stateAndActivations.get(context.getCurrentStateId()));
+                return violations;
+        }
+        
+        // Modified epsilon greedy choose for action based on value function
+        // with probability epsilon, choose the state with probability based on the weight
+        // with probability 1 - epsilon, choose the best state
+        // epsilon should decay w.r.t. time
+        private Object drawWithEpsilonProbabilty(List<Object> activationIds, Map<Object, Double> valueMap, double epsilon, double currentDraw) {
+                if(activationIds.size() <= 0) {
+                        return null;
+                }
+                
+                // if epsilon is smaller than current draw, return greedy choice 
+                if(epsilon < currentDraw) {
+                        return activationIds.remove(0);
+                }else {
+                        //else return draw with probability of the weights
+                        //find the sum of all 1-weights: the smaller the better
+                        double sum = valueMap.values().stream().mapToDouble(d->1).sum();
+                        double rand = Math.random() * sum;
+                        double iterator = 0.0;
+                        Object idToReturn = null;
+                        
+                        // draw an item with probability
+                        for(Object o : valueMap.keySet()) {
+                                iterator += (1);
+                                if(rand < iterator) {
+                                        idToReturn = o;
+                                        break;
                                 }
-                                Collections.shuffle(activationIds);
-                        } catch (NullPointerException e) {
-                                numberOfStatecoderFail++;
-                                activationIds = Collections.emptyList();
                         }
-                        return activationIds;
+                        
+                        //delete the item from the list
+                        activationIds.remove(idToReturn);
+                        valueMap.remove(idToReturn);
+                        return idToReturn;
                 }
+        }
+        
+        private List<Object> selectActivation() {
+                List<Object> activationIds;
+                try {
+                        activationIds = this.activationSelector.randomizeActivationIDs(context.getUntraversedActivationIds());
+                } catch (NullPointerException e) {
+                        numberOfStatecoderFail++;
+                        activationIds = Collections.emptyList();
+                }
+                return activationIds;
+        }
 
-                private void checkForSolution(final Fitness fittness) {
-                        if (fittness.isSatisifiesHardObjectives()) {
-                                logger.debug("Solution Found!!");
-                                logger.debug("# violations: " + (getNumberOfViolations(mustMatchers)));
-                                if (solutionStoreWithDiversityDescriptor.isDifferent(context)) {
-                                        solutionStoreWithCopy.newSolution(context);
-                                        solutionStoreWithDiversityDescriptor.newSolution(context);
-                                        solutionStore.newSolution(context);
-                                        configuration.progressMonitor.workedModelFound(configuration.solutionScope.numberOfRequiredSolution);
+        private void checkForSolution(final Fitness fittness) {
+                if (fittness.isSatisifiesHardObjectives()) {
+                        logger.debug("Solution Found!!");
+                        logger.debug("# violations: " + (getNumberOfViolations(mustMatchers)));
+                        if (solutionStoreWithDiversityDescriptor.isDifferent(context)) {
+                                solutionStoreWithCopy.newSolution(context);
+                                solutionStoreWithDiversityDescriptor.newSolution(context);
+                                solutionStore.newSolution(context);
+                                configuration.progressMonitor.workedModelFound(configuration.solutionScope.numberOfRequiredSolutions);
 
-                                        logger.debug("Found a solution.");
-                                }
+                                logger.debug("Found a solution.");
                         }
                 }
+        }
+        
+        public List<String> times = new LinkedList<String>();
+        private void saveTimes() {
+                long forwardTime = context.getDesignSpaceManager().getForwardTime()/1000000;
+                long backtrackingTime = context.getDesignSpaceManager().getBacktrackingTime()/1000000;
+                long statecoderTime = ((NeighbourhoodBasedPartialInterpretationStateCoder)this.context.getStateCoder()).getStatecoderRuntime()/1000000;
+                long solutionCopy = solutionStoreWithCopy.getSumRuntime()/1000000;
+                long activationSelection = this.activationSelector.getRuntime()/1000000;
+//              long numericalSolverSumTime = this.numericSolver.getRuntime()/1000000;
+//              long numericalSolverProblemForming = this.numericSolver.getSolverSolvingProblem()/1000000;
+//              long numericalSolverSolving = this.numericSolver.getSolverSolvingProblem()/1000000;
+//              long numericalSolverInterpreting = this.numericSolver.getSolverSolution()/1000000;
+                long metricCalculationTime = this.method.getStatistics().metricCalculationTime / 1000000;
+                this.times.add(
+                        "(TransformationExecutionTime"+method.getStatistics().transformationExecutionTime/1000000+ 
+                        "|ForwardTime:"+forwardTime+
+                        "|Backtrackingtime:"+backtrackingTime+
+                        "|StateCoderTime:"+statecoderTime+
+                        "|SolutionCopyTime:"+solutionCopy+
+                        "|ActivationSelectionTime:"+activationSelection+
+                        //"|NumericalSolverSumTime:"+numericalSolverSumTime+
+                        //"|NumericalSolverProblemFormingTime:"+numericalSolverProblemForming+
+                        //"|NumericalSolverSolvingTime:"+numericalSolverSolving+
+                        //"|NumericalSolverInterpretingSolution:"+numericalSolverInterpreting+
+                        "|MetricCalculationTime:"+metricCalculationTime + ")"
+                        );
+                
+        }
 
-                @Override
-                public void interruptStrategy() {
-                        isInterrupted = true;
-                }
+        @Override
+        public void interruptStrategy() {
+                isInterrupted = true;
+        }
 
 
-                private TrajectoryWithFitness selectState() {
-                        int randomNumber = random.nextInt(configuration.randomBacktrackChance);
-                        if (randomNumber == 0) {
-                                int elements = trajectoiresToExplore.size();
-                                int randomElementIndex = random.nextInt(elements);
-                                logger.debug("Randomly backtract to the " + randomElementIndex + " best solution...");
-                                Iterator<TrajectoryWithFitness> iterator = trajectoiresToExplore.iterator();
-                                while (randomElementIndex != 0) {
-                                        iterator.next();
-                                        randomElementIndex--;
-                                }
-                                TrajectoryWithFitness res = iterator.next();
-                                if (res == null) {
-                                        return trajectoiresToExplore.element();
-                                } else {
-                                        return res;
-                                }
-                        } else {
+        private TrajectoryWithFitness selectState() {
+                int randomNumber = random.nextInt(configuration.randomBacktrackChance);
+                if (randomNumber == 0) {
+                        int elements = trajectoiresToExplore.size();
+                        int randomElementIndex = random.nextInt(elements);
+                        logger.debug("Randomly backtract to the " + randomElementIndex + " best solution...");
+                        Iterator<TrajectoryWithFitness> iterator = trajectoiresToExplore.iterator();
+                        while (randomElementIndex != 0) {
+                                iterator.next();
+                                randomElementIndex--;
+                        }
+                        TrajectoryWithFitness res = iterator.next();
+                        if (res == null) {
                                 return trajectoiresToExplore.element();
+                        } else {
+                                return res;
                         }
-                }       
-                
+                } else {
+                        return trajectoiresToExplore.element();
+                }
+        }       
+        
 //              private void logCurrentStateMetric() {
 //                      if(this.configuration.documentationLevel != DocumentationLevel.NONE || workspace == null) {
 //                              return;
@@ -518,77 +579,80 @@ public class HillClimbingOnRealisticMetricStrategyForModelGeneration implements
 //                      PartialInterpretationMetric.calculateMetric(interpretation, "debug/metric/" + context.getModel().hashCode(), context.getCurrentStateId().toString());           
 //              }
 
-                public void visualiseCurrentState() {
-                        PartialInterpretationVisualiser partialInterpretatioVisualiser = configuration.debugCongiguration.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) {
-                                        PartialInterpretationVisualisation visualisation = partialInterpretatioVisualiser.visualiseConcretization(p);
-                                        visualisation.writeToFile(workspace, String.format("state%09d.png", id));
-                                }
+        public void visualiseCurrentState() {
+                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.debugConfiguration.partalInterpretationVisualisationFrequency == 0) {
+                                PartialInterpretationVisualisation visualisation = partialInterpretatioVisualiser.visualiseConcretization(p);
+                                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");
                         }
                 }
+        }
 
-                protected boolean checkConsistency(TrajectoryWithFitness t) {
-                        LogicReasoner internalIncosnsitencyDetector = configuration.internalConsistencyCheckerConfiguration.internalIncosnsitencyDetector;
-                        if (internalIncosnsitencyDetector!= null) {
-                                int id = ++numberOfSolverCalls;
-                                if (id % configuration.internalConsistencyCheckerConfiguration.incternalConsistencyCheckingFrequency == 0) {
-                                        try {
-                                                PartialInterpretation interpretation = (PartialInterpretation) (context.getModel());
-                                                PartialInterpretation copied = EcoreUtil.copy(interpretation);
-                                                this.partialInterpretation2Logic.transformPartialIntepretation2Logic(copied.getProblem(), copied);
-                                                LogicProblem newProblem = copied.getProblem();
+        protected boolean checkConsistency(TrajectoryWithFitness t) {
+                LogicReasoner internalIncosnsitencyDetector = configuration.internalConsistencyCheckerConfiguration.internalIncosnsitencyDetector;
+                if (internalIncosnsitencyDetector!= null) {
+                        int id = ++numberOfSolverCalls;
+                        if (id % configuration.internalConsistencyCheckerConfiguration.incternalConsistencyCheckingFrequency == 0) {
+                                try {
+                                        PartialInterpretation interpretation = (PartialInterpretation) (context.getModel());
+                                        PartialInterpretation copied = EcoreUtil.copy(interpretation);
+                                        this.partialInterpretation2Logic.transformPartialIntepretation2Logic(copied.getProblem(), copied);
+                                        LogicProblem newProblem = copied.getProblem();
 
-                                                this.configuration.typeScopes.maxNewElements = interpretation.getMaxNewElements();
-                                                this.configuration.typeScopes.minNewElements = interpretation.getMinNewElements();
-                                                LogicResult result = internalIncosnsitencyDetector.solve(newProblem, configuration, workspace);
-                                                if (result instanceof InconsistencyResult) {
-                                                        logger.debug("Solver found an Inconsistency!");
-                                                        removeSubtreeFromQueue(t);
-                                                        return true;
-                                                } else if (result instanceof ModelResult) {
-                                                        logger.debug("Solver found a model!");
-                                                        solutionStore.newSolution(context);
+                                        this.configuration.typeScopes.maxNewElements = interpretation.getMaxNewElements();
+                                        this.configuration.typeScopes.minNewElements = interpretation.getMinNewElements();
+                                        LogicResult result = internalIncosnsitencyDetector.solve(newProblem, configuration, workspace);
+                                        if (result instanceof InconsistencyResult) {
+                                                logger.debug("Solver found an Inconsistency!");
+                                                removeSubtreeFromQueue(t);
+                                                return true;
+                                        } else if (result instanceof ModelResult) {
+                                                logger.debug("Solver found a model!");
+                                                solutionStore.newSolution(context);
 
-                                                        this.modelResultByInternalSolver = (ModelResult) result;
-                                                        return true;
-                                                } else {
-                                                        logger.debug("Failed consistency check.");
-                                                        return false;
-                                                }
-                                        } catch (Exception e) {
-                                                logger.debug("Problem with internal consistency checking: "+e.getMessage());
-                                                e.printStackTrace();
+                                                this.modelResultByInternalSolver = (ModelResult) result;
+                                                return true;
+                                        } else {
+                                                logger.debug("Failed consistency check.");
                                                 return false;
                                         }
+                                } catch (Exception e) {
+                                        logger.debug("Problem with internal consistency checking: "+e.getMessage());
+                                        e.printStackTrace();
+                                        return false;
                                 }
-
                         }
-                        return false;
-                }
 
-                protected void removeSubtreeFromQueue(TrajectoryWithFitness t) {
-                        PriorityQueue<TrajectoryWithFitness> previous = this.trajectoiresToExplore;
-                        this.trajectoiresToExplore = new PriorityQueue<>(this.comparator);
-                        for (TrajectoryWithFitness trajectoryWithFitness : previous) {
-                                if (!containsAsSubstring(trajectoryWithFitness.trajectory, t.trajectory)) {
-                                        this.trajectoiresToExplore.add(trajectoryWithFitness);
-                                } else {
-                                        logger.debug("State has been excluded due to inherent inconsistency");
-                                }
-                        }
                 }
+                return false;
+        }
 
-                private boolean containsAsSubstring(Object[] full, Object[] substring) {
-                        if (substring.length > full.length) {
-                                return false;
-                        } else if (substring.length == full.length) {
-                                return Arrays.equals(full, substring);
+        protected void removeSubtreeFromQueue(TrajectoryWithFitness t) {
+                PriorityQueue<TrajectoryWithFitness> previous = this.trajectoiresToExplore;
+                this.trajectoiresToExplore = new PriorityQueue<>(this.comparator);
+                for (TrajectoryWithFitness trajectoryWithFitness : previous) {
+                        if (!containsAsSubstring(trajectoryWithFitness.trajectory, t.trajectory)) {
+                                this.trajectoiresToExplore.add(trajectoryWithFitness);
                         } else {
-                                Object[] part = Arrays.copyOfRange(full, 0, substring.length);
-                                return Arrays.equals(part, substring);
+                                logger.debug("State has been excluded due to inherent inconsistency");
                         }
                 }
+        }
+
+        private boolean containsAsSubstring(Object[] full, Object[] substring) {
+                if (substring.length > full.length) {
+                        return false;
+                } else if (substring.length == full.length) {
+                        return Arrays.equals(full, substring);
+                } else {
+                        Object[] part = Arrays.copyOfRange(full, 0, substring.length);
+                        return Arrays.equals(part, substring);
+                }
+        }
 }
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 9fc6853c..27208cf4 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,99 +1,123 @@
 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.PrimitiveElement

 

-//class ViatraReasonerNumbers {

-//      public static val scopePriority = 2

-//      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

+class ModelGenerationCompositeObjective implements IThreeValuedObjective {

+        val IObjective scopeObjective

         val List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives

         val UnfinishedWFObjective unfinishedWFObjective

-        var boolean isWFOptional = false;

+        var PartialInterpretation model = null

+        val int scopeWeight

+        val int conaintmentWeight

+        val int nonContainmentWeight

+        val int unfinishedWFWeight

         

-        public new(

-                ScopeObjective scopeObjective,

+        new(

+                IObjective scopeObjective,

+                List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives,

+                UnfinishedWFObjective unfinishedWFObjective,

+                ViatraReasonerConfiguration configuration)

+        {

+                this(

+                        scopeObjective, unfinishedMultiplicityObjectives, unfinishedWFObjective,

+                        configuration.scopeWeight, configuration.conaintmentWeight, configuration.nonContainmentWeight,

+                        configuration.unfinishedWFWeight

+                )

+        }

+

+        new(

+                IObjective scopeObjective,

                 List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives,

                 UnfinishedWFObjective unfinishedWFObjective,

-                boolean isWFOptional)

+                int scopeWeight, int conaintmentWeight, int nonContainmentWeight, int unfinishedWFWeight)

         {

                 this.scopeObjective = scopeObjective

                 this.unfinishedMultiplicityObjectives = unfinishedMultiplicityObjectives

                 this.unfinishedWFObjective = unfinishedWFObjective

-                this.isWFOptional = isWFOptional;

-        }

-        

-        def getIsWFOptional(){

-                return this.isWFOptional;

+                

+                this.scopeWeight = scopeWeight

+                this.conaintmentWeight = conaintmentWeight

+                this.nonContainmentWeight = nonContainmentWeight

+                this.unfinishedWFWeight = unfinishedWFWeight

         }

         

         override init(ThreadContext context) {

+                model = context.model as PartialInterpretation

                 this.scopeObjective.init(context)

                 this.unfinishedMultiplicityObjectives.forEach[it.init(context)]

                 this.unfinishedWFObjective.init(context)

         }

-        

+

         override createNew() {

                 return new ModelGenerationCompositeObjective(

-                        this.scopeObjective, this.unfinishedMultiplicityObjectives, this.unfinishedWFObjective, this.isWFOptional)

+                        scopeObjective.createNew,

+                        ImmutableList.copyOf(unfinishedMultiplicityObjectives.map[createNew as UnfinishedMultiplicityObjective]),

+                        unfinishedWFObjective.createNew as UnfinishedWFObjective,

+                        scopeWeight, conaintmentWeight, nonContainmentWeight, unfinishedWFWeight

+                )

         }

-        

+

         override getComparator() { Comparators.LOWER_IS_BETTER }

+

         override getFitness(ThreadContext context) {

-                var sum = 0.0

+                

                 val scopeFitnes = scopeObjective.getFitness(context)

-                //val unfinishedMultiplicitiesFitneses = unfinishedMultiplicityObjectives.map[x|x.getFitness(context)]

+                val unfinishedWFsFitness = unfinishedWFObjective.getFitness(context)

                 

-                sum+=scopeFitnes

-                var multiplicity = 0.0

+                var containmentMultiplicity = 0.0

+                var nonContainmentMultiplicity = 0.0

                 for(multiplicityObjective : unfinishedMultiplicityObjectives) {

-                        multiplicity+=multiplicityObjective.getFitness(context)//*0.5

+                        val multiplicity = multiplicityObjective.getFitness(context)

+//                      println(multiplicityObjective.name + "=" + multiplicity)

+                        if(multiplicityObjective.containment) {

+                                containmentMultiplicity+=multiplicity

+                        } else {

+                                nonContainmentMultiplicity+=multiplicity

+                        }

+                        

                 }

-                sum+=multiplicity

                 

-                // the WF can be optional when generating realistic models

-                if(!isWFOptional){

-                        val unfinishedWFsFitness = unfinishedWFObjective.getFitness(context)

-                        sum += unfinishedWFsFitness//*0.5

-                }

+                var sum = 0.0

+                sum += scopeFitnes*scopeWeight

+                sum += containmentMultiplicity*conaintmentWeight

+                sum += nonContainmentMultiplicity*nonContainmentWeight

+                sum += unfinishedWFsFitness*unfinishedWFWeight

                 

-                //println('''Sum=«sum»|Scope=«scopeFitnes»|Multiplicity=«multiplicity»|WFs=«unfinishedWFsFitness»''')

+//              println('''scope=«scopeFitnes», containment=«containmentMultiplicity», nonContainment=«nonContainmentMultiplicity», wf=«unfinishedWFsFitness», sum=«sum»''')

                 

                 return sum

         }

         

-        override getLevel() { 2 }

-        override getName() { "CompositeUnfinishednessObjective"}

-        def getObjective(){

-                return this.unfinishedMultiplicityObjectives;

+        override getWorstPossibleFitness(ThreadContext threadContext) {

+                Double.POSITIVE_INFINITY

         }

         

+        override getBestPossibleFitness(ThreadContext threadContext) {

+                0.0

+        }

+

+        override getLevel() { 2 }

+

+        override getName() { "CompositeUnfinishednessObjective" }

+

         override isHardObjective() { true }

-        override satisifiesHardObjective(Double fitness) { fitness <= 0.001 }

-        

-        

+

+        override satisifiesHardObjective(Double fitness) { fitness < 0.01 }

+

         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
new file mode 100644
index 00000000..70e8e9c2
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/NumericSolver.xtend
@@ -0,0 +1,192 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse

+

+import hu.bme.mit.inf.dslreasoner.viatra2logic.NumericTranslator

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BooleanElement

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.IntegerElement

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PrimitiveElement

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.RealElement

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.StringElement

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ModelGenerationMethod

+import java.math.BigDecimal

+import java.util.HashMap

+import java.util.LinkedHashMap

+import java.util.LinkedHashSet

+import java.util.List

+import java.util.Map

+import org.eclipse.emf.ecore.EObject

+import org.eclipse.viatra.dse.base.ThreadContext

+import org.eclipse.viatra.query.runtime.api.IPatternMatch

+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher

+import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint

+

+class NumericSolver {

+        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

+        

+        val boolean intermediateConsistencyCheck

+        val boolean caching;

+        Map<LinkedHashMap<PConstraint, Iterable<List<Integer>>>,Boolean> satisfiabilityCache = new HashMap

+        

+        var long runtime = 0

+        var long cachingTime = 0 

+        var int numberOfSolverCalls = 0

+        var int numberOfCachedSolverCalls = 0

+        

+        new(ModelGenerationMethod method, boolean intermediateConsistencyCheck, boolean caching) {

+                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

+                        val querySpec = entry.value

+                        val matcher = querySpec.getMatcher(engine);

+                        constraint2MustUnitPropagationPrecondition.put(constraint,matcher)

+                }

+                for(entry : method.currentUnitPropagationPreconditions.entrySet) {

+                        val constraint = entry.key

+                        val querySpec = entry.value

+                        val matcher = querySpec.getMatcher(engine);

+                        constraint2CurrentUnitPropagationPrecondition.put(constraint,matcher)

+                }

+        }

+        

+        def getRuntime(){runtime}

+        def getCachingTime(){cachingTime}

+        def getNumberOfSolverCalls(){numberOfSolverCalls}

+        def getNumberOfCachedSolverCalls(){numberOfCachedSolverCalls}

+        def getSolverFormingProblem(){this.t.formingProblemTime}

+        def getSolverSolvingProblem(){this.t.solvingProblemTime}

+        def getSolverSolution(){this.t.formingSolutionTime}

+        

+        def boolean maySatisfiable() {

+                if(intermediateConsistencyCheck) {

+                        return isSatisfiable(this.constraint2MustUnitPropagationPrecondition)

+                } else {

+                        return true

+                }

+        }

+        def boolean currentSatisfiable() {

+                isSatisfiable(this.constraint2CurrentUnitPropagationPrecondition)

+        }

+        

+        private def boolean isSatisfiable(Map<PConstraint,ViatraQueryMatcher<? extends IPatternMatch>> matches) {

+                val start = System.nanoTime

+                var boolean finalResult 

+                if(matches.empty){

+                        finalResult=true

+                } else {

+                        val propagatedConstraints = new HashMap

+                        for(entry : matches.entrySet) {

+                                val constraint = entry.key

+                                //println(constraint)

+                                val allMatches = entry.value.allMatches.map[it.toArray]

+                                //println(allMatches.toList)

+                                propagatedConstraints.put(constraint,allMatches)

+                        }

+                        if(propagatedConstraints.values.forall[empty]) {

+                                finalResult=true

+                        } else {

+                                if(caching) {

+                                        val code = getCode(propagatedConstraints)

+                                        val cachedResult = satisfiabilityCache.get(code)

+                                        if(cachedResult === null) {

+        //                                      println('''new problem, call solver''')

+        //                                      for(entry : code.entrySet) {

+        //                                              println('''«entry.key» -> «entry.value»''')

+        //                                      }

+                                                //println(code.hashCode)

+                                                this.numberOfSolverCalls++

+                                                val res = t.delegateIsSatisfiable(propagatedConstraints)

+                                                satisfiabilityCache.put(code,res)

+                                                finalResult=res

+                                        } else {

+                                                //println('''similar problem, answer from cache''')

+                                                finalResult=cachedResult

+                                                this.numberOfCachedSolverCalls++

+                                        }

+                                } else {

+                                        finalResult= t.delegateIsSatisfiable(propagatedConstraints)

+                                        this.numberOfSolverCalls++

+                                }

+                        }

+                }       

+                this.runtime+=System.nanoTime-start

+                return finalResult

+        }

+        

+        def getCode(HashMap<PConstraint, Iterable<Object[]>> propagatedConstraints) {

+                val start = System.nanoTime

+                val involvedObjects = new LinkedHashSet(propagatedConstraints.values.flatten.map[toList].flatten.toList).toList

+                val res = new LinkedHashMap(propagatedConstraints.mapValues[matches | matches.map[objects | objects.map[object | involvedObjects.indexOf(object)].toList]])

+                this.cachingTime += System.nanoTime-start

+                return res

+        }

+        

+        def fillSolutionCopy(Map<EObject, EObject> trace) {

+                val model = threadContext.getModel as PartialInterpretation

+                val dataObjects = model.newElements.filter(PrimitiveElement).filter[!model.openWorldElements.contains(it)].toList

+                if(constraint2CurrentUnitPropagationPrecondition.empty) {

+                        fillWithDefaultValues(dataObjects,trace)

+                } else {

+                        val propagatedConstraints = new HashMap

+                        for(entry : constraint2CurrentUnitPropagationPrecondition.entrySet) {

+                                val constraint = entry.key

+                                val allMatches = entry.value.allMatches.map[it.toArray]

+                                propagatedConstraints.put(constraint,allMatches)

+                        }

+                        

+                        if(propagatedConstraints.values.forall[empty]) {

+                                fillWithDefaultValues(dataObjects,trace)

+                        } else {

+                                val solution = t.delegateGetSolution(dataObjects,propagatedConstraints)

+                                fillWithSolutions(dataObjects,solution,trace)

+                        }

+                }

+        }

+        

+        def protected fillWithDefaultValues(List<PrimitiveElement> elements, Map<EObject, EObject> trace) {

+                for(element : elements) {

+                        if(element.valueSet==false) {

+                                val value = getDefaultValue(element)

+                                val target = trace.get(element) as PrimitiveElement

+                                target.fillWithValue(value)

+                        }

+                }

+        }

+        

+        def protected dispatch getDefaultValue(BooleanElement e) {false}

+        def protected dispatch getDefaultValue(IntegerElement e) {0}

+        def protected dispatch getDefaultValue(RealElement e) {0.0}

+        def protected dispatch getDefaultValue(StringElement e) {""}

+        

+        def protected fillWithSolutions(List<PrimitiveElement> elements, Map<PrimitiveElement, Number> solution, Map<EObject, EObject> trace) {

+                for(element : elements) {

+                        if(element.valueSet==false) {

+                                if(solution.containsKey(element)) {

+                                        val value = solution.get(element)

+                                        val target = trace.get(element) as PrimitiveElement

+                                        target.fillWithValue(value)

+                                } else {

+                                        val target = trace.get(element) as PrimitiveElement

+                                        target.fillWithValue(target.defaultValue)

+                                }

+                        }

+                }

+        }

+        

+        def protected dispatch fillWithValue(BooleanElement e, Object value) {e.valueSet=true e.value=value as Boolean}

+        def protected dispatch fillWithValue(IntegerElement e, Object value) {e.valueSet=true e.value=value as Integer}

+        def protected dispatch fillWithValue(RealElement e, Object value) {e.valueSet=true e.value=BigDecimal.valueOf(value as Double) }

+        def protected dispatch fillWithValue(StringElement e, Object value) {e.valueSet=true e.value=value as String}

+}
\ 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/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 f61c7333..b48d0831 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
@@ -22,12 +22,13 @@ import java.util.List
 import java.util.Map

 import java.util.TreeSet

 import org.eclipse.emf.ecore.EObject

+import org.eclipse.xtend.lib.annotations.Accessors

 import org.eclipse.xtext.xbase.lib.Functions.Function1

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

 

 class PartialModelAsLogicInterpretation implements LogicModelInterpretation{

-        val PartialInterpretation partialInterpretation

+        @Accessors val PartialInterpretation partialInterpretation

         val Map<EObject, EObject> trace;

         val Map<TypeDeclaration,PartialComplexTypeInterpretation> type2Interpretation

         val Map<RelationDeclaration,PartialRelationInterpretation> relation2Interpretation

@@ -153,14 +154,70 @@ class PartialModelAsLogicInterpretation implements LogicModelInterpretation{
         }

         

         override getAllIntegersInStructure() {

-                new TreeSet(this.integerForwardTrace.keySet)

+                new TreeSet(allIntegersWithInterpretation.values)

+        }

+        

+        override getAllIntegersWithInterpretation() {

+                val builder = new HashMap

+                for (entry : integerForwardTrace.entrySet) {

+                        builder.put(entry.value, entry.key)

+                }

+                for (element : partialInterpretation.newElements) {

+                        if (element instanceof IntegerElement) {

+                                builder.put(element, element.value)

+                        }

+                }

+                builder

         }

         

         override getAllRealsInStructure() {

-                new TreeSet(this.realForwardTrace.keySet)

+                new TreeSet(allRealsWithInterpretation.values)

+        }

+        

+        override getAllRealsWithInterpretation() {

+                val builder = new HashMap

+                for (entry : realForwardTrace.entrySet) {

+                        builder.put(entry.value, entry.key)

+                }

+                for (element : partialInterpretation.newElements) {

+                        if (element instanceof RealElement) {

+                                builder.put(element, element.value)

+                        }

+                }

+                builder

         }

         

         override getAllStringsInStructure() {

-                new TreeSet(this.stringForwardTrace.keySet)

+                new TreeSet(allStringsWithInterpretation.values)

+        }

+        

+        override getAllStringsWithInterpretation() {

+                val builder = new HashMap

+                for (entry : stringForwardTrace.entrySet) {

+                        builder.put(entry.value, entry.key)

+                }

+                for (element : partialInterpretation.newElements) {

+                        if (element instanceof StringElement) {

+                                builder.put(element, element.value)

+                        }

+                }

+                builder

+        }

+        

+        override getAllBooleansInStructure() {

+                new TreeSet(allBooleansWithInterpretation.values)

+        }

+        

+        override getAllBooleansWithInterpretation() {

+                val builder = new HashMap

+                for (entry : booleanForwardTrace.entrySet) {

+                        builder.put(entry.value, entry.key)

+                }

+                for (element : partialInterpretation.newElements) {

+                        if (element instanceof BooleanElement) {

+                                builder.put(element, element.value)

+                        }

+                }

+                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/PunishSizeObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PunishSizeObjective.xtend
new file mode 100644
index 00000000..bad8e4d1
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/PunishSizeObjective.xtend
@@ -0,0 +1,52 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PrimitiveElement
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.AbstractThreeValuedObjective
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveKind
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveThreshold
+import org.eclipse.viatra.dse.base.ThreadContext
+
+class PunishSizeObjective extends AbstractThreeValuedObjective {
+        static val NAME = typeof(PunishSizeObjective).name
+        
+        new(ObjectiveKind kind, int level) {
+                super(NAME, kind, ObjectiveThreshold.NO_THRESHOLD, level)
+        }
+        
+        override createNew() {
+                new PunishSizeObjective(kind, level)
+        }
+        
+        override init(ThreadContext context) {
+                // Nothing to initialize.
+        }
+        
+        override getRawFitness(ThreadContext threadContext) {
+                val model = threadContext.model
+                if (model instanceof PartialInterpretation) {
+                        val size = model.newObjectCount
+//                      println('''size=«size»''')
+                        size as double
+                } else {
+                        throw new IllegalArgumentException("notifier must be a PartialInterpretation")
+                }
+        }
+        
+        override getLowestPossibleFitness(ThreadContext threadContext) {
+                getRawFitness(threadContext)
+        }
+        
+        override getHighestPossibleFitness(ThreadContext threadContext) {
+                val model = threadContext.model
+                if (model instanceof PartialInterpretation) {
+                        (model.newObjectCount + model.maxNewElements) as double
+                } else {
+                        throw new IllegalArgumentException("notifier must be a PartialInterpretation")
+                }
+        }
+        
+        private def getNewObjectCount(PartialInterpretation interpretation) {
+                interpretation.newElements.reject[it instanceof PrimitiveElement].size
+        }
+}
\ 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..b61bd20b 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..888eda18
--- /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,82 @@
+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 copiedSolutions = new LinkedHashMap<Object, CopiedSolution>
+
+        @Accessors NumericSolver numericSolver
+        long startTime = System.nanoTime
+        @Accessors(PUBLIC_GETTER) long totalCopierRuntime = 0
+
+        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 a8b7301e..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 {

         

@@ -25,7 +23,7 @@ class SolutionStoreWithCopy {
                 newSolution(context)

         }*/

         

-        def newSolution(ThreadContext context) {

+        def Map<EObject,EObject> newSolution(ThreadContext context) {

                 //print(System.nanoTime-initTime + ";")

                 val copyStart = System.nanoTime

                 val solution = context.model as PartialInterpretation

@@ -36,6 +34,7 @@ class SolutionStoreWithCopy {
                 copyTraces.add(copier)

                 runtime += System.nanoTime - copyStart

                 solutionTimes.add(System.nanoTime-sartTime)

+                return copier

         }

         def getSumRuntime() {

                 return runtime

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 aad9a448..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,9 +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 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.ArrayList

 import java.util.Collection

-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine

-import org.eclipse.viatra.query.runtime.emf.EMFScope

-import org.eclipse.viatra.dse.base.ThreadContext

+import java.util.Comparator

 import java.util.List

+import org.eclipse.viatra.dse.base.ThreadContext

 import org.eclipse.viatra.dse.objectives.Comparators

-import java.util.ArrayList

-import java.util.Comparator

+import org.eclipse.viatra.dse.objectives.IObjective

+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))

-                for(unfinishedWF : unfinishedWFs) {

+                val engine = context.queryEngine // ViatraQueryEngine.on(new EMFScope(context.model))

+                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»''')

-                        sumOfMatches+=number

+//                      if (number > 0) {

+//                              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..e00f76ff
--- /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,250 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Bounds
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.DirectionalThresholdObjective
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.IObjectiveBoundsProvider
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveThreshold
+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, IObjectiveBoundsProvider {
+        static val TOLERANCE = 1e-10
+
+        @Accessors val SolutionCopier solutionCopier
+        @Accessors val DiversityChecker diversityChecker
+        val IObjective[][] leveledExtremalObjectives
+        val boolean hasExtremalObjectives
+        val int numberOfRequiredSolutions
+        val ObjectiveComparatorHelper comparatorHelper
+        val Map<SolutionTrajectory, Fitness> trajectories = new HashMap
+
+        @Accessors var NumericSolver numericSolver
+        @Accessors var Map<Object, Solution> solutionsCollection
+
+        new(IObjective[][] leveledExtremalObjectives, int numberOfRequiredSolutions, DiversityChecker diversityChecker) {
+                this.diversityChecker = diversityChecker
+                comparatorHelper = new ObjectiveComparatorHelper(leveledExtremalObjectives)
+                this.leveledExtremalObjectives = leveledExtremalObjectives
+                hasExtremalObjectives = leveledExtremalObjectives.exists[!empty]
+                this.numberOfRequiredSolutions = numberOfRequiredSolutions
+                this.solutionCopier = new SolutionCopier
+        }
+        
+        def setNumericSolver(NumericSolver numericSolver) {
+                this.numericSolver = numericSolver
+                solutionCopier.numericSolver = 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
+                }
+                println("Found: " + fitness)
+                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) {
+                fitness.satisifiesHardObjectives && (numericSolver === null || numericSolver.currentSatisfiable)
+        }
+
+        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
+        }
+
+        override computeRequiredBounds(IObjective objective, Bounds bounds) {
+                if (!hasExtremalObjectives) {
+                        return
+                }
+                if (objective instanceof DirectionalThresholdObjective) {
+                        switch (threshold : objective.threshold) {
+                                case ObjectiveThreshold.NO_THRESHOLD: {
+                                        // No threshold to set.
+                                }
+                                ObjectiveThreshold.Exclusive: {
+                                        switch (kind : objective.kind) {
+                                                case HIGHER_IS_BETTER:
+                                                        bounds.tightenLowerBound(Math.floor(threshold.threshold + 1) as int)
+                                                case LOWER_IS_BETTER:
+                                                        bounds.tightenUpperBound(Math.ceil(threshold.threshold - 1) as int)
+                                                default:
+                                                        throw new IllegalArgumentException("Unknown objective kind" + kind)
+                                        }
+                                        if (threshold.clampToThreshold) {
+                                                return
+                                        }
+                                }
+                                ObjectiveThreshold.Inclusive: {
+                                        switch (kind : objective.kind) {
+                                                case HIGHER_IS_BETTER:
+                                                        bounds.tightenLowerBound(Math.ceil(threshold.threshold) as int)
+                                                case LOWER_IS_BETTER:
+                                                        bounds.tightenUpperBound(Math.floor(threshold.threshold) as int)
+                                                default:
+                                                        throw new IllegalArgumentException("Unknown objective kind" + kind)
+                                        }
+                                        if (threshold.clampToThreshold) {
+                                                return
+                                        }
+                                }
+                                default:
+                                        throw new IllegalArgumentException("Unknown threshold: " + threshold)
+                        }
+                        for (level : leveledExtremalObjectives) {
+                                switch (level.size) {
+                                        case 0: {
+                                                // Nothing to do, wait for the next level.
+                                        }
+                                        case 1: {
+                                                val primaryObjective = level.get(0)
+                                                if (primaryObjective != objective) {
+                                                        // There are no worst-case bounds for secondary objectives.
+                                                        return
+                                                }
+                                        }
+                                        default:
+                                                // There are no worst-case bounds for Pareto front calculation.
+                                                return
+                                }
+                        }
+                        val fitnessIterator = trajectories.values.iterator
+                        if (!fitnessIterator.hasNext) {
+                                return
+                        }
+                        val fitness = fitnessIterator.next.get(objective.name)
+                        while (fitnessIterator.hasNext) {
+                                val otherFitness = fitnessIterator.next.get(objective.name)
+                                if (Math.abs(fitness - otherFitness) > TOLERANCE) {
+                                        throw new IllegalStateException("Inconsistent fitness: " + objective.name)
+                                }
+                        }
+                        switch (kind : objective.kind) {
+                                case HIGHER_IS_BETTER:
+                                        if (needsMoreSolutionsWithSameFitness) {
+                                                bounds.tightenLowerBound(Math.floor(fitness) as int)
+                                        } else {
+                                                bounds.tightenLowerBound(Math.floor(fitness + 1) as int)
+                                        }
+                                case LOWER_IS_BETTER:
+                                        if (needsMoreSolutionsWithSameFitness) {
+                                                bounds.tightenUpperBound(Math.ceil(fitness) as int)
+                                        } else {
+                                                bounds.tightenUpperBound(Math.ceil(fitness - 1) as int)
+                                        }
+                                default:
+                                        throw new IllegalArgumentException("Unknown objective kind" + kind)
+                        }
+                }
+        }
+}
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)

-        {

-                val res = new ConstraintsObjective('''unfinishedWFs''',

-                        unfinishedWF.map[

-                                new QueryConstraint(it.fullyQualifiedName,it,2.0)

-                        ].toList

+                Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWF) {

+                new UnfinishedWFObjective(unfinishedWF)

+        }

+

+        def createInvalidationObjective(

+                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

-        }

-        

-        def IGlobalConstraint createInvalidationObjective(

-                Collection<? extends IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidatedByWF)

-        {

-                return new ModelQueriesGlobalConstraint('''invalidatedWFs''',

-                        new ArrayList(invalidatedByWF)

-                )

+                res

         }

-}
\ 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/CostElementMatchers.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CostElementMatchers.xtend
new file mode 100644
index 00000000..885b14e8
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CostElementMatchers.xtend
@@ -0,0 +1,137 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import com.google.common.collect.ImmutableList
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage
+import java.util.List
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.xtend.lib.annotations.Data
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+
+@FunctionalInterface
+interface ParameterScopeBound {
+        def double getUpperBound()
+}
+
+@Data
+class CostElementMatch {
+        val IPatternMatch match
+        val boolean must
+
+        def isMulti() {
+                CostElementMatchers.isMultiMatch(match)
+        }
+}
+
+@Data
+class CostElementMatchers {
+        val ViatraQueryMatcher<? extends IPatternMatch> currentMatcher
+        val ViatraQueryMatcher<? extends IPatternMatch> mayMatcher
+        val ViatraQueryMatcher<? extends IPatternMatch> mustMatcher
+        val List<ParameterScopeBound> parameterScopeBounds
+        val int weight
+
+        def getCurrentNumberOfMatches() {
+                currentMatcher.countMatches
+        }
+
+        def getMinimumNumberOfMatches() {
+                mustMatcher.countMatches
+        }
+
+        def getMaximumNumberOfMatches() {
+                var double sum = 0
+                val iterator = mayMatcher.streamAllMatches.iterator
+                while (iterator.hasNext) {
+                        val match = iterator.next
+                        var double product = 1
+                        val numberOfParameters = parameterScopeBounds.size
+                        for (var int i = 0; i < numberOfParameters; i++) {
+                                if (isMulti(match.get(i + 2))) {
+                                        val scopeBound = parameterScopeBounds.get(i)
+                                        product *= scopeBound.upperBound
+                                }
+
+                        }
+                        sum += product
+                }
+                sum
+        }
+
+        def getMatches() {
+                ImmutableList.copyOf(mayMatcher.streamAllMatches.iterator.map [ match |
+                        new CostElementMatch(match, mustMatcher.isMatch(match))
+                ])
+        }
+        
+        def projectMayMatch(IPatternMatch match, int... indices) {
+                mayMatcher.projectMatch(match, indices)
+        }
+        
+        private static def <T extends IPatternMatch> projectMatch(ViatraQueryMatcher<T> matcher, IPatternMatch match, int... indices) {
+                checkMatch(match)
+                val n = matcher.specification.parameters.length - 2
+                if (indices.length != n) {
+                        throw new IllegalArgumentException("Invalid number of projection indices")
+                }
+                val newMatch = matcher.newEmptyMatch
+                newMatch.set(0, match.get(0))
+                newMatch.set(1, match.get(1))
+                for (var int i = 0; i < n; i++) {
+                        newMatch.set(i + 2, match.get(indices.get(i)))
+                }
+                if (!matcher.hasMatch(newMatch)) {
+                        throw new IllegalArgumentException("Projected match does not exist")
+                }
+                return newMatch
+        }
+
+        private static def <T extends IPatternMatch> isMatch(ViatraQueryMatcher<T> matcher, IPatternMatch match) {
+                val n = matcher.specification.parameters.length
+                if (n != match.specification.parameters.length) {
+                        throw new IllegalArgumentException("Invalid number of match arguments")
+                }
+                val newMatch = matcher.newEmptyMatch
+                for (var int i = 0; i < n; i++) {
+                        newMatch.set(i, match.get(i))
+                }
+                return matcher.hasMatch(newMatch)
+        }
+
+        static def isMulti(Object o) {
+                if (o instanceof EObject) {
+                        switch (feature : o.eContainmentFeature) {
+                                case LogicproblemPackage.eINSTANCE.logicProblem_Elements,
+                                case PartialinterpretationPackage.eINSTANCE.partialInterpretation_NewElements:
+                                        false
+                                case PartialinterpretationPackage.eINSTANCE.partialInterpretation_OpenWorldElements:
+                                        true
+                                default:
+                                        throw new IllegalStateException("Unknown containment feature for element: " + feature)
+                        }
+                } else {
+                        false
+                }
+        }
+
+        static def isMultiMatch(IPatternMatch match) {
+                checkMatch(match)
+                val n = match.specification.parameters.length
+                for (var int i = 2; i < n; i++) {
+                        if (isMulti(match.get(i))) {
+                                return true
+                        }
+                }
+                false
+        }
+        
+        private static def checkMatch(IPatternMatch match) {
+                val n = match.specification.parameters.length
+                if (n < 2 || !(match.get(0) instanceof LogicProblem) || !(match.get(1) instanceof PartialInterpretation)) {
+                        throw new IllegalArgumentException("Match is not from the partial interpretation")
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CostObjectiveHint.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CostObjectiveHint.xtend
new file mode 100644
index 00000000..2434073d
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CostObjectiveHint.xtend
@@ -0,0 +1,68 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.BoundSaturationListener
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ExtendedLinearExpressionBuilder
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearTypeConstraintHint
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearTypeExpressionBuilderFactory
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronExtensionOperator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PatternGenerator
+import java.util.Map
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
+import org.eclipse.xtend.lib.annotations.Accessors
+
+abstract class CostObjectiveHint implements LinearTypeConstraintHint, BoundSaturationListener {
+        @Accessors ThreeValuedCostObjective objective
+        @Accessors IObjectiveBoundsProvider boundsProvider
+        
+        Integer bestUpper = null
+
+        override getAdditionalPatterns(PatternGenerator patternGenerator, Map<String, PQuery> fqnToPQuery) {
+                ''''''
+        }
+
+        override createConstraintUpdater(LinearTypeExpressionBuilderFactory builderFactory) {
+                null
+        }
+        
+        def isExact() {
+                false
+        }
+
+        def PolyhedronExtensionOperator createPolyhedronExtensionOperator(
+                Map<String, CostElementMatchers> costElementMatchers) {
+                null
+        }
+        
+        def setObjective(ThreeValuedCostObjective objective) {
+                if (this.objective !== null) {
+                        throw new IllegalStateException("Objective was already set")
+                }
+                this.objective = objective
+        }
+        
+        def setBoundsProvider(IObjectiveBoundsProvider boundsProvider) {
+                if (this.boundsProvider !== null) {
+                        throw new IllegalStateException("Objective bounds provider was already set")
+                }
+                this.boundsProvider = boundsProvider
+        }
+        
+        protected def buildWithBounds(ExtendedLinearExpressionBuilder builder) {
+                val bounds = builder.build(this)
+                if (objective !== null && boundsProvider !== null) {
+                        boundsProvider.computeRequiredBounds(objective, bounds)
+                }
+                if (exact && bestUpper !== null) {
+                        bounds.tightenLowerBound(bestUpper)
+                }
+                bounds
+        }
+        
+        override boundsSaturated(Integer lower, Integer upper) {
+                if (upper !== null && (bestUpper === null || bestUpper < upper)) {
+                        bestUpper = upper
+                }
+                objective?.boundsSaturated(lower, upper)
+        }
+        
+}
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/IObjectiveBoundsProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IObjectiveBoundsProvider.xtend
new file mode 100644
index 00000000..3c4d36a5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IObjectiveBoundsProvider.xtend
@@ -0,0 +1,8 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Bounds
+import org.eclipse.viatra.dse.objectives.IObjective
+
+interface IObjectiveBoundsProvider {
+        def void computeRequiredBounds(IObjective objective, Bounds bounds)
+}
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..9b1a7e9f
--- /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,80 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.BoundSaturationListener
+import java.util.Map
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.xtend.lib.annotations.Accessors
+
+class ThreeValuedCostObjective extends AbstractThreeValuedObjective implements BoundSaturationListener {
+        @Accessors val Map<String, CostElementMatchers> matchers
+        double lowerBoundHint = Double.NEGATIVE_INFINITY
+        double upperBoundHint = Double.POSITIVE_INFINITY
+
+        new(String name, Map<String, CostElementMatchers> matchers, ObjectiveKind kind, ObjectiveThreshold threshold,
+                int level) {
+                super(name, kind, threshold, level)
+                this.matchers = matchers
+        }
+
+        override createNew() {
+                // new ThreeValuedCostObjective(name, matchers, kind, threshold, level)
+                throw new UnsupportedOperationException("ThreeValuedCostObjective can only be used from a single thread")
+        }
+
+        override init(ThreadContext context) {
+        }
+
+        override getRawFitness(ThreadContext context) {
+                var double cost = 0
+                for (matcher : matchers.values) {
+                        cost += matcher.weight * matcher.currentNumberOfMatches
+                }
+                cost
+        }
+
+        override getLowestPossibleFitness(ThreadContext threadContext) {
+                var double cost = 0
+                for (matcher : matchers.values) {
+                        if (matcher.weight >= 0) {
+                                cost += matcher.weight * matcher.minimumNumberOfMatches
+                        } else {
+                                cost += matcher.weight * matcher.maximumNumberOfMatches
+                        }
+                }
+                val boundWithHint = Math.max(lowerBoundHint, cost)
+                if (boundWithHint > upperBoundHint) {
+                        throw new IllegalStateException("Inconsistent cost bounds")
+                }
+                boundWithHint
+        }
+
+        override getHighestPossibleFitness(ThreadContext threadContext) {
+                var double cost = 0
+                for (matcher : matchers.values) {
+                        if (matcher.weight <= 0) {
+                                cost += matcher.weight * matcher.minimumNumberOfMatches
+                        } else {
+                                cost += matcher.weight * matcher.maximumNumberOfMatches
+                        }
+                }
+                val boundWithHint = Math.min(upperBoundHint, cost)
+                if (boundWithHint < lowerBoundHint) {
+                        throw new IllegalStateException("Inconsistent cost bounds")
+                }
+                boundWithHint
+        }
+
+        override boundsSaturated(Integer lower, Integer upper) {
+                lowerBoundHint = if (lower === null) {
+                        Double.NEGATIVE_INFINITY
+                } else {
+                        lower
+                }
+                upperBoundHint = if (upper === null) {
+                        Double.POSITIVE_INFINITY
+                } else {
+                        upper
+                }
+                println('''Bounds saturated: «lower»..«upper»''')
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjectiveProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjectiveProvider.xtend
new file mode 100644
index 00000000..c2750acd
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjectiveProvider.xtend
@@ -0,0 +1,205 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.ImmutableMap
+import com.google.common.collect.Lists
+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.Relation
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.StringTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeReference
+import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransfomedViatraQuery
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronExtensionOperator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.ModalPatternQueries
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialBooleanInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialIntegerInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRealInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialStringInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.CostObjectiveConfiguration
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.CostObjectiveElementConfiguration
+import java.util.Collection
+import java.util.Map
+import org.eclipse.viatra.dse.objectives.IObjective
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine
+import org.eclipse.xtend.lib.annotations.Data
+
+@Data
+class ThreeValuedCostObjectiveProviderResult {
+        val Collection<IObjective> objectives
+        val Collection<CostObjectiveHint> hints
+        val Collection<PolyhedronExtensionOperator> extensionOperators
+        val IObjective[][] leveledExtremalObjectives
+        val boolean optimizationProblem
+}
+
+class ThreeValuedCostObjectiveProvider {
+        static val COST_OBJECTIVE_LEVEL = 3
+
+        val ViatraQueryEngine queryEngine
+        val Map<String, ModalPatternQueries> modalRelationQueries
+        val Map<String, Relation> qualifiedNameToRelationMap
+        val ParameterScopeBound defaultBounds
+        val ParameterScopeBound booleanBounds
+        val ParameterScopeBound integerBounds
+        val ParameterScopeBound realBounds
+        val ParameterScopeBound stringBounds
+        val Map<TypeDeclaration, ParameterScopeBound> typeDeclarationToBoundsMap
+
+        new(ViatraQueryEngine queryEngine, PartialInterpretation interpretation,
+                Map<String, ModalPatternQueries> modalRelationQueries) {
+                this.queryEngine = queryEngine
+                this.modalRelationQueries = modalRelationQueries
+                qualifiedNameToRelationMap = ImmutableMap.copyOf(
+                        interpretation.problem.annotations.filter(TransfomedViatraQuery).
+                                toMap([patternFullyQualifiedName], [target]))
+                defaultBounds = new PartialInterpretationBasedParameterScopeBound(interpretation)
+                var ParameterScopeBound booleanBounds = null
+                var ParameterScopeBound integerBounds = null
+                var ParameterScopeBound realBounds = null
+                var ParameterScopeBound stringBounds = null
+                val typeDeclarationToBoundsMapBuilder = ImmutableMap.builder
+                for (scope : interpretation.scopes) {
+                        val bounds = new ScopeBasedParameterScopeBound(scope)
+                        switch (typeInterpretation : scope.targetTypeInterpretation) {
+                                PartialBooleanInterpretation:
+                                        if (booleanBounds === null) {
+                                                booleanBounds = bounds
+                                        } else {
+                                                throw new IllegalStateException("Duplicate partial boolean interpretation")
+                                        }
+                                PartialIntegerInterpretation:
+                                        if (integerBounds === null) {
+                                                integerBounds = bounds
+                                        } else {
+                                                throw new IllegalStateException("Duplicate partial integer interpretation")
+                                        }
+                                PartialRealInterpretation:
+                                        if (realBounds === null) {
+                                                realBounds = bounds
+                                        } else {
+                                                throw new IllegalStateException("Duplicate partial real interpretation")
+                                        }
+                                PartialStringInterpretation:
+                                        if (stringBounds === null) {
+                                                stringBounds = bounds
+                                        } else {
+                                                throw new IllegalStateException("Duplicate partial string interpretation")
+                                        }
+                                PartialComplexTypeInterpretation:
+                                        typeDeclarationToBoundsMapBuilder.put(typeInterpretation.interpretationOf, bounds)
+                        }
+                }
+                this.booleanBounds = booleanBounds ?: defaultBounds
+                this.integerBounds = integerBounds ?: defaultBounds
+                this.realBounds = realBounds ?: defaultBounds
+                this.stringBounds = stringBounds ?: defaultBounds
+                typeDeclarationToBoundsMap = typeDeclarationToBoundsMapBuilder.build
+        }
+
+        def getCostObjectives(Collection<CostObjectiveConfiguration> costObjectives) {
+                val objectives = ImmutableList.<IObjective>builder
+                val hints = ImmutableList.<CostObjectiveHint>builder
+                val extensionOperators = ImmutableList.<PolyhedronExtensionOperator>builder
+                val extremalObjectives = Lists.newArrayListWithExpectedSize(costObjectives.size)
+                for (entry : costObjectives.indexed) {
+                        val objectiveName = '''costObjective«entry.key»'''
+                        val objectiveConfig = entry.value
+                        val costObjective = transformCostObjective(objectiveConfig, objectiveName)
+                        objectives.add(costObjective)
+                        if (objectiveConfig.findExtremum) {
+                                extremalObjectives += costObjective
+                        }
+                        val hint = objectiveConfig.hint
+                        if (hint !== null) {
+                                hints.add(hint)
+                                hint.objective = costObjective
+                                val extensionOperator = hint.createPolyhedronExtensionOperator(costObjective.matchers)
+                                if (extensionOperator !== null) {
+                                        extensionOperators.add(extensionOperator)
+                                }
+                        }
+                }
+                new ThreeValuedCostObjectiveProviderResult(
+                        objectives.build,
+                        hints.build,
+                        extensionOperators.build,
+                        newArrayList(extremalObjectives),
+                        !extremalObjectives.empty
+                )
+        }
+
+        private def transformCostObjective(CostObjectiveConfiguration configuration, String name) {
+                val costElements = ImmutableMap.copyOf(configuration.elements.toMap([patternQualifiedName], [
+                        transformCostElement
+                ]))
+                new ThreeValuedCostObjective(name, costElements, configuration.kind, configuration.threshold,
+                        COST_OBJECTIVE_LEVEL)
+        }
+
+        private def transformCostElement(CostObjectiveElementConfiguration elementConfig) {
+                val relationName = elementConfig.patternQualifiedName
+                val modalQueries = modalRelationQueries.get(relationName)
+                if (modalQueries === null) {
+                        throw new IllegalArgumentException("Unknown relation queries: " + relationName)
+                }
+                val relation = qualifiedNameToRelationMap.get(relationName)
+                if (relation === null) {
+                        throw new IllegalArgumentException("Unknown transformed relation: " + relationName)
+                }
+                val parameterBounds = ImmutableList.copyOf(relation.parameters.map[parameterBound])
+                new CostElementMatchers(
+                        queryEngine.getMatcher(modalQueries.currentQuery),
+                        queryEngine.getMatcher(modalQueries.mayQuery),
+                        queryEngine.getMatcher(modalQueries.mustQuery),
+                        parameterBounds,
+                        elementConfig.weight
+                )
+        }
+
+        private def getParameterBound(TypeReference typeReference) {
+                switch (typeReference) {
+                        BoolTypeReference: booleanBounds
+                        IntTypeReference: integerBounds
+                        RealTypeReference: realBounds
+                        StringTypeReference: stringBounds
+                        ComplexTypeReference: typeDeclarationToBoundsMap.getOrDefault(typeReference.referred, defaultBounds)
+                }
+        }
+
+        private static abstract class AbstractParameterScopeBound implements ParameterScopeBound {
+                override getUpperBound() {
+                        val rawValue = rawUpperBound
+                        if (rawValue < 0) {
+                                Double.POSITIVE_INFINITY
+                        } else {
+                                rawValue
+                        }
+                }
+
+                protected def int getRawUpperBound()
+        }
+
+        @Data
+        private static class ScopeBasedParameterScopeBound extends AbstractParameterScopeBound {
+                val Scope scope
+
+                override protected getRawUpperBound() {
+                        scope.maxNewElements
+                }
+        }
+
+        @Data
+        private static class PartialInterpretationBasedParameterScopeBound extends AbstractParameterScopeBound {
+                val PartialInterpretation interpretation
+
+                override protected getRawUpperBound() {
+                        interpretation.maxNewElements
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/META-INF/MANIFEST.MF b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/META-INF/MANIFEST.MF
index 2abc6d50..754ff55d 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/META-INF/MANIFEST.MF
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/META-INF/MANIFEST.MF
@@ -27,8 +27,7 @@ Require-Bundle: com.google.guava,
  org.apache.batik.util.gui;bundle-version="[1.6.0,1.6.1]",

  org.apache.xerces;bundle-version="2.9.0",

  org.w3c.dom.svg;bundle-version="1.1.0",

- org.w3c.css.sac;bundle-version="1.3.1",

- org.eclipse.m2e.maven.runtime.slf4j.simple;bundle-version="1.10.0"

+ org.w3c.css.sac;bundle-version="1.3.1"

 Import-Package: com.eclipsesource.v8;version="4.6.0",

  com.eclipsesource.v8.debug;version="4.6.0",

  com.eclipsesource.v8.utils;version="4.6.0",

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/GraphvizV8WithMemory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/GraphvizV8WithMemory.xtend
new file mode 100644
index 00000000..542289d4
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/GraphvizV8WithMemory.xtend
@@ -0,0 +1,16 @@
+package hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz

+

+import guru.nidi.graphviz.engine.GraphvizV8Engine

+

+class GraphvizV8WithMemory extends GraphvizV8Engine {

+        val int memory;

+        new(int memory) {

+                this.memory = memory

+                //this.

+        }

+        

+        override protected jsInitEnv() {

+                println super.jsInitEnv()

+                super.jsInitEnv()

+        }

+}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/PartialInterpretation2Graphviz.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/PartialInterpretation2Graphviz.xtend
index 78326207..cd0b3e00 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/PartialInterpretation2Graphviz.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/PartialInterpretation2Graphviz.xtend
@@ -30,6 +30,7 @@ import org.eclipse.xtext.xbase.lib.Functions.Function1
 import static guru.nidi.graphviz.model.Factory.*

 

 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PrimitiveElement

 

 class GraphvizVisualiser implements PartialInterpretationVisualiser {

         

@@ -106,10 +107,10 @@ class GraphvizVisualiser implements PartialInterpretationVisualiser {
 //                      elements2Node.put(newElement,image)

 //              }

                 

-                partialInterpretation.newElements.filter(BooleanElement).drawDataTypes([it.value.toString],elements2Node,elements2ID)

-                partialInterpretation.newElements.filter(IntegerElement).drawDataTypes([it.value.toString],elements2Node,elements2ID)

-                partialInterpretation.newElements.filter(StringElement).drawDataTypes(['''"«it.value.toString»"'''],elements2Node,elements2ID)

-                partialInterpretation.newElements.filter(RealElement).drawDataTypes([it.value.toString],elements2Node,elements2ID)

+                //partialInterpretation.newElements.filter(BooleanElement).drawDataTypes([it.value.toString],elements2Node,elements2ID)

+                //partialInterpretation.newElements.filter(IntegerElement).drawDataTypes([it.value.toString],elements2Node,elements2ID)

+                //partialInterpretation.newElements.filter(StringElement).drawDataTypes(['''"«it.value.toString»"'''],elements2Node,elements2ID)

+                //partialInterpretation.newElements.filter(RealElement).drawDataTypes([it.value.toString],elements2Node,elements2ID)

                 

                 // Drawing the edges

                 val edges = new HashMap

@@ -135,35 +136,51 @@ class GraphvizVisualiser implements PartialInterpretationVisualiser {
                 return new GraphvizVisualisation(graph)

         }

         

-        def protected <T extends DefinedElement> void drawDataTypes(Iterable<T> collection, Function1<T,String> namer, HashMap<DefinedElement, Node> elements2Node, HashMap<DefinedElement, String> elements2ID) {

-                for(booleanElementIndex: 0..<collection.size) {

-                        val newElement = collection.get(booleanElementIndex)

-                        val id = namer.apply(newElement)

-                        val image = drawElement(newElement,id,false,emptySet,emptySet)

-                        elements2ID.put(newElement,id)

-                        elements2Node.put(newElement,image)

-                }

-        }

+//      def protected <T extends DefinedElement> void drawDataTypes(Iterable<T> collection, Function1<T,String> namer, HashMap<DefinedElement, Node> elements2Node, HashMap<DefinedElement, String> elements2ID) {

+//              for(booleanElementIndex: 0..<collection.size) {

+//                      val newElement = collection.get(booleanElementIndex)

+//                      val name = namer.apply(newElement)

+//                      val image = drawElement(newElement,name,newElement.lookup(elements2ID),false,emptySet,emptySet)

+//                      elements2Node.put(newElement,image)

+//              }

+//      }

         

         def protected drawElement(DefinedElement element, String ID, boolean old, Set<Type> mustTypes, Set<Type> mayTypes) {

                 var tableStyle =  ''' CELLSPACING="0" BORDER="2" CELLBORDER="0" CELLPADDING="1" STYLE="ROUNDED"'''

                 if(typeColoringStyle==TypeColoringStyle::AVERAGE) {

                         tableStyle += ''' BGCOLOR="#«typePredicateColor(mustTypes).toBackgroundColorString»"'''

                 }

-                val mainLabel = if(element.name !== null) {

+                val mainLabel = if(element instanceof PrimitiveElement) {

+                        if(element.isValueSet) {

+                                if(element instanceof BooleanElement) { element.value.toString }

+                                else if(element instanceof IntegerElement) { element.value.toString }

+                                else if(element instanceof RealElement) { element.value.toString }

+                                else if(element instanceof StringElement) { "\""+element.value.toString+"\"" }

+                        } else {

+                                "?"

+                        }

+                 }else if(element.name !== null) {

                         val parts = element.name.split("\\s+")

                         textWithSubSup(parts.getOrNull(0),parts.getOrNull(1),parts.getOrNull(2),null)

                 } else {

                         val parts = ID.split("\\s+")

-                        textWithSubSup(parts.get(0),parts.get(1),parts.getOrNull(2),null)

+                        textWithSubSup(parts.getOrNull(0),parts.getOrNull(1),parts.getOrNull(2),null)

                 }

-                val label = Label.html(

+                val hasNoCompexType = (mustTypes.empty) && (mayTypes.empty)

+                

+                val label = if(hasNoCompexType) {

+                        Label.html(

+                                '''<TABLE«tableStyle»>'''+

+                                '''<TR><TD COLSPAN="2">    «mainLabel»  </TD></TR>'''+

+                                '''</TABLE>''')

+                } else {

+                        Label.html(

                         '''<TABLE«tableStyle»>'''+

                         '''<TR><TD COLSPAN="2" BORDER="2" SIDES="B">«mainLabel»</TD></TR>'''+

                         '''«FOR mustTypeName : mustTypes.map[it.name].sort»«typePredicateDescription(mustTypeName,true)»«ENDFOR»'''+

                         '''«FOR mayTypeName : mayTypes.map[it.name].sort»«typePredicateDescription(mayTypeName,false)»«ENDFOR»'''+

                         '''</TABLE>''')

-                        

+                }

                 val node = node(ID).with(label).with(

                         Shape.NONE

                         //,

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/VisualisationQueque.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/VisualisationQueque.xtend
index b067ba7d..6f003f80 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/VisualisationQueque.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.visualisation/src/hu/bme/mit/inf/dslreasoner/visualisation/pi2graphviz/VisualisationQueque.xtend
@@ -3,15 +3,15 @@ package hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz
 import guru.nidi.graphviz.engine.Format

 import guru.nidi.graphviz.engine.Graphviz

 import guru.nidi.graphviz.engine.GraphvizEngine

-import guru.nidi.graphviz.engine.GraphvizV8Engine

 import guru.nidi.graphviz.model.Graph

 import java.io.File

 import java.io.IOException

 import java.util.concurrent.BlockingQueue

 import java.util.concurrent.CompletableFuture

 import java.util.concurrent.LinkedBlockingQueue

-import org.eclipse.xtend.lib.annotations.Data

 import java.util.function.Consumer

+import org.eclipse.xtend.lib.annotations.Data

+import guru.nidi.graphviz.engine.GraphvizV8Engine

 

 class VisualisationQueque {

         val BlockingQueue<VisualisationQueueEntry> taskQueue = new LinkedBlockingQueue

@@ -45,7 +45,7 @@ class VisualisationQueque {
                 } else {

                         runnerThread = new Thread(new Runnable() {

                                 override run() {

-                                        val engine = new GraphvizV8Engine()

+                                        val engine = new GraphvizV8Engine

                                         val nullConsumer = new Consumer<GraphvizEngine>() {

                                                 override accept(GraphvizEngine t) {}

                                         }

@@ -69,7 +69,7 @@ class VisualisationQueque {
         private def execute(GraphvizEngine engine, Graph document, File targetFile, Format format) {

                 Graphviz.useEngine(engine);

                 try {

-                        Graphviz.fromGraph(document).render(format).toFile(targetFile)

+                        Graphviz.fromGraph(document).totalMemory(536870912).render(format).toFile(targetFile)

                         return null

                 } catch(IOException e){

                         return e.message

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/.classpath b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/.classpath
new file mode 100644
index 00000000..ed0eb24c
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+        <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="src" path="src/"/>
+        <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/.project b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/.project
new file mode 100644
index 00000000..aa414f43
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+        <name>org.eclipse.viatra.dse</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/VIATRA-Solver/org.eclipse.viatra.dse/.settings/org.eclipse.jdt.core.prefs b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 00000000..9f6ece88
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,8 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.release=disabled
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/META-INF/MANIFEST.MF b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/META-INF/MANIFEST.MF
new file mode 100644
index 00000000..fabef844
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/META-INF/MANIFEST.MF
@@ -0,0 +1,387 @@
+Manifest-Version: 1.0

+Automatic-Module-Name: org.eclipse.viatra.dse

+Bundle-SymbolicName: org.eclipse.viatra.dse;singleton:=true

+Require-Bundle: org.eclipse.viatra.query.runtime;bundle-version="[2.4.

+ 0,2.5.0)";visibility:=reexport,org.eclipse.viatra.transformation.evm;

+ bundle-version="[2.4.0,2.5.0)";visibility:=reexport,org.eclipse.emf.e

+ core,org.eclipse.emf.ecore.xmi;bundle-version="2.7.0",org.eclipse.emf

+ .edit,org.eclipse.viatra.transformation.runtime.emf;bundle-version="[

+ 2.4.0,2.5.0)";visibility:=reexport

+Bundle-ManifestVersion: 2

+Bundle-RequiredExecutionEnvironment: JavaSE-1.8

+Bundle-ActivationPolicy: lazy

+Eclipse-SourceReferences: scm:git:git://git.eclipse.org/gitroot/viatra

+ /org.eclipse.viatra.git;path="dse/plugins/org.eclipse.viatra.dse";com

+ mitId=2a7314b6b21df594743fa017d18ae62da85c73fa

+Bundle-Vendor: Eclipse VIATRA Project

+Import-Package: com.google.common.base;version="27.1.0",com.google.com

+ mon.collect;version="27.1.0",com.google.common.util.concurrent;versio

+ n="27.1.0",org.apache.log4j;version="1.2.15"

+Export-Package: org.eclipse.viatra.dse.api,org.eclipse.viatra.dse.api.

+ strategy.impl,org.eclipse.viatra.dse.api.strategy.interfaces,org.ecli

+ pse.viatra.dse.base,org.eclipse.viatra.dse.designspace.api,org.eclips

+ e.viatra.dse.multithreading,org.eclipse.viatra.dse.objectives,org.ecl

+ ipse.viatra.dse.objectives.impl,org.eclipse.viatra.dse.solutionstore,

+ org.eclipse.viatra.dse.statecode,org.eclipse.viatra.dse.statecoding,o

+ rg.eclipse.viatra.dse.statecoding.simple,org.eclipse.viatra.dse.util,

+ org.eclipse.viatra.dse.visualizer

+SCM-Revision: 2a7314b6b21df594743fa017d18ae62da85c73fa

+Bundle-Name: VIATRA-DSE framework Base (Incubation)

+Bundle-Version: 0.24.0.202005060951

+Build-Jdk-Spec: 1.8

+Created-By: Maven Archiver 3.5.0

+

+Name: org/eclipse/viatra/dse/objectives/impl/NoRuleActivationsHardObje

+ ctive.class

+SHA-256-Digest: nEIutogP27RZKAUo9eH/DshkhyOF8voUnj4BC/pkhYU=

+

+Name: org/eclipse/viatra/dse/statecoding/simple/SimpleStateCoder$1.cla

+ ss

+SHA-256-Digest: t7KG11FngBrFGTPHJuEaP5BvpPqRYMDq8qKuQyccRWQ=

+

+Name: org/eclipse/viatra/dse/base/ThreadContext.class

+SHA-256-Digest: 0Z+RpFCBKvn1+SVJSLpRbEpoMATPujvvfqGsBr99mBI=

+

+Name: org/eclipse/viatra/dse/objectives/impl/ModelQueriesGlobalConstra

+ int.class

+SHA-256-Digest: 3qw4e1RY7TqpTKHRngBjCRWfJmMmu+DiUnKHO0yXVA4=

+

+Name: org/eclipse/viatra/dse/objectives/IObjective.class

+SHA-256-Digest: io0MQDhFysUXcHYcPUZENsy/xLn98SE65b2RbJ7QttM=

+

+Name: org/eclipse/viatra/dse/statecoding/simple/SimpleStateCoder.class

+SHA-256-Digest: yOvisOPQT9D/tuLV5fLonIoDpqi8bSRbPVjtLtv4UKo=

+

+Name: org/eclipse/viatra/dse/base/ExplorerThread.class

+SHA-256-Digest: N4tY8yMnFoKGoMyS0RdRtqpGIh6ucbvvAxnf/YPr/xk=

+

+Name: org/eclipse/viatra/dse/solutionstore/SolutionStore$BestSolutionS

+ aver.class

+SHA-256-Digest: yZkg5ntRMOsrKEgo7kkAaK5J8h11Ng8tzH4QXsLRhsM=

+

+Name: org/eclipse/viatra/dse/api/strategy/impl/RandomSearchStrategy$Sh

+ aredData.class

+SHA-256-Digest: 2jBwT4lfAUh7LDDmpi3JuzyjcWhVeb+53PPB5ZKlGx4=

+

+Name: org/eclipse/viatra/dse/base/DseIdPoolHelper$IGetRuleExecutions.c

+ lass

+SHA-256-Digest: s7Pr9OPNF5baYmoZlOTWl6keA+b1TVxV8zxBXMGewrM=

+

+Name: org/eclipse/viatra/dse/api/strategy/impl/RandomSearchStrategy.cl

+ ass

+SHA-256-Digest: 0R8ENAT9UA3BCsveA38VjvR4k+Um3i1fFlQB85inLZY=

+

+Name: org/eclipse/viatra/dse/api/DesignSpaceExplorer.class

+SHA-256-Digest: JCDN006fVS56ROn6cV7Ssdl4CN+xtbdiWjVfDkkgRDM=

+

+Name: org/eclipse/viatra/dse/util/EMFHelper$ENamedElementComparator.cl

+ ass

+SHA-256-Digest: J8o5TEdYpuU/6q1qTw3lUIHaE4pEH/EpDUvuTNWusVA=

+

+Name: org/eclipse/viatra/dse/util/ValueComparableEObjectStringMap$EObj

+ ectComparator.class

+SHA-256-Digest: iwLJSS2Ip9WvN2lC8gfg+ys5Cp+P7ZSpGP6QF5lKYKQ=

+

+Name: org/eclipse/viatra/dse/api/DesignSpaceExplorer$DseLoggingLevel.c

+ lass

+SHA-256-Digest: z3h4wzaSMGzPvV4KL6ilStnLdT/mVCNNp7C/AwfQhqk=

+

+Name: org/eclipse/viatra/dse/multithreading/DSEThreadPool.class

+SHA-256-Digest: XoKcmDnafPfiyQ0LemN0ni31T+aY+lXp/Q8p157kj/g=

+

+Name: org/eclipse/viatra/dse/api/strategy/impl/DepthFirstStrategy.clas

+ s

+SHA-256-Digest: SGlKz9PbynZwkmaJ1rpE0kVUOHl7vl7GOscNFoNEHLg=

+

+Name: org/eclipse/viatra/dse/base/GlobalContext.class

+SHA-256-Digest: dLn/Iu9JVDaaKK21VeFAMDXGaJWROEJCWJjULwMzNik=

+

+Name: org/eclipse/viatra/dse/statecoding/IncrementalObjectProvider.cla

+ ss

+SHA-256-Digest: L0yK9bhku/F8MX/NyKoBuydeMbMgZir8N0BRcFzHnKs=

+

+Name: org/eclipse/viatra/dse/statecode/IStateCoderFactory.class

+SHA-256-Digest: 1GsfU5aBQs1ieo3dblcXFZ07oq9QzWr1NZLppgSdCOM=

+

+Name: org/eclipse/viatra/dse/base/DesignSpaceManager$1.class

+SHA-256-Digest: /suIApW5KeZ7OifoR8SRPc3gU+2B8/ZnWInhdpAOTd8=

+

+Name: org/eclipse/viatra/dse/objectives/ActivationFitnessProcessor.cla

+ ss

+SHA-256-Digest: vML6AN6aCbn/cKeccmvzRAai47jZJk0CpYhwFQdhwvI=

+

+Name: org/eclipse/viatra/dse/solutionstore/IdBasedSolutionNameProvider

+ .class

+SHA-256-Digest: QFWpXui2nID6PKhTHs/1e0gj9u8NiniES6/G0C/oSzM=

+

+Name: org/eclipse/viatra/dse/api/strategy/impl/BreadthFirstStrategy$Bf

+ sSharedObject.class

+SHA-256-Digest: wVno1chuJ8pYpfv5cpB0fjsGbO2s+2OWcaVQgoQb5+k=

+

+Name: org/eclipse/viatra/dse/objectives/TrajectoryFitness.class

+SHA-256-Digest: DIEgS7SFg5pWuxvFhRn3f7hBt8+qk1+40w9WpOkoyrc=

+

+Name: org/eclipse/viatra/dse/solutionstore/SolutionStore$1.class

+SHA-256-Digest: V5AAqo4/81KOegdl1Wl8jIBrH57y4TdYrj+wOzV2vdM=

+

+Name: org/eclipse/viatra/dse/api/Solution.class

+SHA-256-Digest: U71jRd/R8tarIiHM+dETwXiwwPcmXO5m82bDUp/Mduo=

+

+Name: org/eclipse/viatra/dse/util/EMFHelper$EmfHelperException.class

+SHA-256-Digest: +OCT0+wqq9XGCze/qDE8hh3zprFMBAnkR7H1J7k/Htk=

+

+Name: org/eclipse/viatra/dse/base/DseEvmRuleBase.class

+SHA-256-Digest: iRILqfjFCMPd020YX8dMyRaNlUGfEUTd4N3gnqQRtDo=

+

+Name: org/eclipse/viatra/dse/objectives/impl/TrajectoryCostSoftObjecti

+ ve.class

+SHA-256-Digest: wXSfFPucpZyh72nGKuKn83N63Orl75XUM9SkzKfFBi4=

+

+Name: org/eclipse/viatra/dse/api/DSETransformationRule.class

+SHA-256-Digest: 01Ngrz/qbLR6j/4z9NxvtD2jHQAHMl698POXw8BSpPY=

+

+Name: org/eclipse/viatra/dse/objectives/impl/ModelQueryType.class

+SHA-256-Digest: SS0yM7NbAU0U4KoA4Tzy4gXKZ2IZaszyaqbtSN4GE74=

+

+Name: org/eclipse/viatra/dse/base/DseConflictResolver.class

+SHA-256-Digest: kLquKehufJSc2fJoUgztO62ucr1UUqfLQpyiFrY8BJc=

+

+Name: org/eclipse/viatra/dse/statecoding/TheStateCoderFactory.class

+SHA-256-Digest: 7tog5/ud60nPTYwPT6HHpHBDeutpFl2KLKXt8GnM3U8=

+

+Name: org/eclipse/viatra/dse/solutionstore/LogSolutionHandler.class

+SHA-256-Digest: cbpeCy8w558CbnhljT2TKalNqWBpKlIsMppr6hWDRpw=

+

+Name: org/eclipse/viatra/dse/designspace/api/TrajectoryInfo.class

+SHA-256-Digest: mXYUokn/RePXJXnfL7O3AZjvwqFkwiLZ0IipQGgdp0A=

+

+Name: org/eclipse/viatra/dse/statecoding/StatecodingDependencyType.cla

+ ss

+SHA-256-Digest: ef+0X9EnYYjpPiRNmjXrElCCaPekh+Wh6yimRTpp15E=

+

+Name: org/eclipse/viatra/dse/objectives/impl/CompositeObjective.class

+SHA-256-Digest: SJiO5Oina3I760xBUDGc4qYp1WrcSG6Yh0+8hQKf69U=

+

+Name: org/eclipse/viatra/dse/objectives/ObjectiveComparatorHelper.clas

+ s

+SHA-256-Digest: +uKjMIfQvBlKY9djJoP5Wd/EBKMkbrdk7shGdZ0rS2M=

+

+Name: org/eclipse/viatra/dse/api/Objectives.class

+SHA-256-Digest: pNQDcSeUV3oOM7aCgscjJwdyysQrMSZCyLhrSWLMUrI=

+

+Name: org/eclipse/viatra/dse/visualizer/DesignSpaceVisualizerOptions.c

+ lass

+SHA-256-Digest: nf/uvPeNaC8Nu9SPhk+sgvSheB/kh+GqsXXHbm7qer0=

+

+Name: org/eclipse/viatra/dse/api/DSEException.class

+SHA-256-Digest: MCUPB2tBDK01enENQDJ+qONxtl+WQyZaJf87iU+NFyU=

+

+Name: org/eclipse/viatra/dse/base/SingletonSetConflictResolver.class

+SHA-256-Digest: bd4gh7UG91EkNSE0JrpAKbHDxv6HYhL7YEq7PZZkRjo=

+

+Name: org/eclipse/viatra/dse/statecoding/IObjectsProvider.class

+SHA-256-Digest: SIcYuklHbTwYjV+gvS1B77Z0CR/2bannTSL77/qm/Gs=

+

+Name: org/eclipse/viatra/dse/statecoding/IncrementalObjectProviderFact

+ ory.class

+SHA-256-Digest: F12xo+nr94L4B1m1w2xmtA7t1TzGin5pFSEqkBmYxC0=

+

+Name: org/eclipse/viatra/dse/api/SolutionTrajectory.class

+SHA-256-Digest: uFjxXsF4khsOwgCsmRPMZbSayZ4qTDtwPGxDBH2lG74=

+

+Name: org/eclipse/viatra/dse/solutionstore/SolutionStore$SimpleSolutio

+ nSaver.class

+SHA-256-Digest: 12aDZULU6fhdXx8a/BvCQwXW7RZfEmIPFueU7GOpBB0=

+

+Name: org/eclipse/viatra/dse/util/Hasher.class

+SHA-256-Digest: 0nFBMPZ6/YudYlnE/l8XiECkWIHBRvkdyi9WUCIaN4c=

+

+Name: org/eclipse/viatra/dse/solutionstore/ISolutionNameProvider.class

+SHA-256-Digest: Ig8utojCZoNY8V37gbZVVJFOX8NZiu2tPsnAIkS1BaU=

+

+Name: org/eclipse/viatra/dse/objectives/IGlobalConstraint.class

+SHA-256-Digest: UvJwqLRVvv444GgELIu/tUGs4eV8cf/Anqh6horECP8=

+

+Name: org/eclipse/viatra/dse/solutionstore/SolutionStore.class

+SHA-256-Digest: V9OJ/9GqLq9cBToiBzapjyCs3mDuk4PkeduT5YpiTwE=

+

+Name: org/eclipse/viatra/dse/objectives/impl/DepthHardObjective.class

+SHA-256-Digest: Ra8i2f1YiRldwF06QotRoHkhKJLyGMYJnS6Lco1ldTM=

+

+Name: org/eclipse/viatra/dse/objectives/impl/BaseObjective.class

+SHA-256-Digest: DH8BIQo1OvBt5oEtS4sqsjtGOhlD1Nwz2yv7gdW3/hA=

+

+Name: org/eclipse/viatra/dse/api/DesignSpaceExplorer$1.class

+SHA-256-Digest: 1AccsshxVCMI2GPkioO7lQtS9JwPx17YrPTSjTZfqBQ=

+

+Name: org/eclipse/viatra/dse/objectives/impl/ConstraintsObjective.clas

+ s

+SHA-256-Digest: +eesnPuyvrf4xQOslHAFlNIyd4K9scCn8f6qprCxKzs=

+

+Name: org/eclipse/viatra/dse/api/strategy/impl/FixedPriorityStrategy.c

+ lass

+SHA-256-Digest: /+Dkno94lswrX5YEr60iH8szAKDL9hfAe2ZZ/amSe20=

+

+Name: org/eclipse/viatra/dse/base/IDseStrategyContext.class

+SHA-256-Digest: ACDjZwH6zo71KF8hXuAvC7NWmGPDv9lJ06U/iAptwEw=

+

+Name: org/eclipse/viatra/dse/statecode/IStateCoder.class

+SHA-256-Digest: L+foclr4t9XV4ltc7aDor4Ngf135J+UvTpTxCcegz9M=

+

+Name: org/eclipse/viatra/dse/objectives/impl/NeverSatisfiedDummyHardOb

+ jective.class

+SHA-256-Digest: KB8QybGLqya7vrKCMnwRdCOaJ/URoTIeR1NVYDNiOB4=

+

+Name: org/eclipse/viatra/dse/objectives/impl/AlwaysSatisfiedDummyHardO

+ bjective.class

+SHA-256-Digest: TzG4kskc7rM96sfpJc6YsSNF7PyE48NJLkUpkkwqsiI=

+

+Name: org/eclipse/viatra/dse/base/DesignSpaceManager.class

+SHA-256-Digest: WlF2FWYiBFQNAW2PsPpPorz64wQBWssTC/73maFotD8=

+

+Name: org/eclipse/viatra/dse/visualizer/IExploreEventHandler.class

+SHA-256-Digest: ZJwhUYNU+L1B88hsbfdIejJVUwhnvBjJSDHugw+RFh0=

+

+Name: META-INF/maven/org.eclipse.viatra/org.eclipse.viatra.dse/pom.pro

+ perties

+SHA-256-Digest: 0JWWPFaIUkYh4BehmajscXzAloPgjeIs0iZSPFC/g1g=

+

+Name: org/eclipse/viatra/dse/statecoding/StatecodingDependency.class

+SHA-256-Digest: AeHJlVqUAUsjBlYumYq/e/WEBNbtlvCk00SG9rHPO88=

+

+Name: org/eclipse/viatra/dse/api/strategy/interfaces/IStrategy.class

+SHA-256-Digest: K5feGvnijYpwPJCOvR4m7ChtC7wX7LhLaau5/SBnFek=

+

+Name: org/eclipse/viatra/dse/visualizer/IDesignSpaceVisualizer.class

+SHA-256-Digest: gF2AAXk6xxQIDqdn56Aeifqmj71pBicLO7VJJoB64bY=

+

+Name: org/eclipse/viatra/dse/solutionstore/SolutionStore$ANumberOfEnou

+ ghSolutions.class

+SHA-256-Digest: qAOxgehQKfKkDSF2W2Gk/cXkDIBsQuN4yJ8Q3eRCnps=

+

+Name: META-INF/maven/org.eclipse.viatra/org.eclipse.viatra.dse/pom.xml

+SHA-256-Digest: /LSOqjjd6+fmn3MHbXK9bGr7k+1GKE3kgzaDoJkgCQQ=

+

+Name: org/eclipse/viatra/dse/base/DseIdPoolHelper$IdProvider.class

+SHA-256-Digest: VRQcpABZNkp3Lgivy9PUraJf04riM1MOZvY64suvo3M=

+

+Name: org/eclipse/viatra/dse/statecoding/simple/SimpleStateCoder$2.cla

+ ss

+SHA-256-Digest: NqiG7/1poRDLI2BbRvr2hfHZqH73hfFxBic+4YKHcCM=

+

+Name: org/eclipse/viatra/dse/base/ThreadContext$GetRuleExecutionsImpl.

+ class

+SHA-256-Digest: HGFHcAmOg3O3se9FT4oE4pWZ8EFdyRkkHkBVJZi+hmM=

+

+Name: org/eclipse/viatra/dse/api/strategy/impl/BestFirstStrategy.class

+SHA-256-Digest: qJyc4dMUiLGVoJPrMWQtCI2o2HW5p6Ki5J8Ra6wb/gE=

+

+Name: org/eclipse/viatra/dse/designspace/api/IDesignSpace.class

+SHA-256-Digest: IS5IjYyUCvaHWBvUsPFeGFv65W+YTG7u+iRXp/eDIuM=

+

+Name: org/eclipse/viatra/dse/api/strategy/impl/HillClimbingStrategy.cl

+ ass

+SHA-256-Digest: UfrnKlXVqN8LWbUPSoA5PDiJOT7cnCA46kIXicC5mg0=

+

+Name: org/eclipse/viatra/dse/api/strategy/impl/BestFirstStrategy$Traje

+ ctoryWithFitness.class

+SHA-256-Digest: n3K90JLwOOVAXsrkROhn0ZNogaAKVdcUpXBj8RUMI3c=

+

+Name: org/eclipse/viatra/dse/util/EMFHelper$MetaModelElements.class

+SHA-256-Digest: FjS8V9JksWMjbV9a1dn04gWFH3fctq9HdWSfbMsV5Ck=

+

+Name: org/eclipse/viatra/dse/statecoding/simple/SimpleStateCoderFactor

+ y.class

+SHA-256-Digest: jcBdVzrTpamZrT0pQZHyJJnooB+DKF6ADVS4RRhZGl4=

+

+Name: org/eclipse/viatra/dse/objectives/Fitness.class

+SHA-256-Digest: CJPJnXYS0WMnW4JVW2YO5/vvwKhRkRE7qROa87Ailpg=

+

+Name: org/eclipse/viatra/dse/api/strategy/impl/BreadthFirstStrategy.cl

+ ass

+SHA-256-Digest: 4odjR0x9jzt7Ed/hw6Q+ydZUrQQggqL8y216Lq60azM=

+

+Name: org/eclipse/viatra/dse/api/Strategies.class

+SHA-256-Digest: tURHC++pafgodWMnk4CperJDpZ9m4Do6xHAV37bHUoc=

+

+Name: org/eclipse/viatra/dse/statecoding/StatecodingNode.class

+SHA-256-Digest: 2xM/ShgCBqpV9tgQZPBxzTSPgbT7lcp7auQE14dEEqc=

+

+Name: org/eclipse/viatra/dse/solutionstore/SolutionStore$ISolutionSave

+ r.class

+SHA-256-Digest: nuYmJKeNKfM0a9sAbRpA6Knzqu51hlK011aoAQpTH3Q=

+

+Name: org/eclipse/viatra/dse/statecoding/StatecodingDependencyGraph.cl

+ ass

+SHA-256-Digest: 9ZxUtKP6+hvWqY9l0b+opdginEK1BoksdLqZ+DYViqI=

+

+Name: org/eclipse/viatra/dse/util/EMFHelper.class

+SHA-256-Digest: hpOu0HMuLuiLYUbg0rhdfVG4/ZrlVftoKLmTsRAHW/E=

+

+Name: org/eclipse/viatra/dse/base/DesignSpaceManager$2.class

+SHA-256-Digest: x8i8lLzE/UkaQJya1kGbTlJnB/JFNy5607FLESkMQXA=

+

+Name: org/eclipse/viatra/dse/base/ActivationCodesConflictSet.class

+SHA-256-Digest: 0G/W2cxiS4R9GEpBWovAIEA4brmQ2sTjqi1F7vgS0/c=

+

+Name: org/eclipse/viatra/dse/api/SolutionTrajectory$1.class

+SHA-256-Digest: 7epxs7VJgi7Jmo2pKb22m2OLhOOIu3OHTJrWC8HjEzQ=

+

+Name: org/eclipse/viatra/dse/solutionstore/SolutionStore$IEnoughSoluti

+ ons.class

+SHA-256-Digest: /5Ux9DFOI3UHcG8om2rGzX2k0Yj1lIoeG/tR82P3zpQ=

+

+Name: org/eclipse/viatra/dse/objectives/impl/ConstraintsObjective$Quer

+ yConstraint.class

+SHA-256-Digest: 79pmTnUZbgOHEdGzyj5PIb2eGrd554q3c17LNdbTQxM=

+

+Name: org/eclipse/viatra/dse/objectives/Comparators.class

+SHA-256-Digest: V5MzedIHj3KBEBbR4UNAhqmbqB3sHuk183zxMlKhGD4=

+

+Name: org/eclipse/viatra/dse/statecoding/IObjectsProviderFactory.class

+SHA-256-Digest: VlWdfwyWo39xhvgIF9PedWC+Yv1Q0hYaDBSF7Z+ClSA=

+

+Name: org/eclipse/viatra/dse/base/GlobalContext$ExplorationProcessStat

+ e.class

+SHA-256-Digest: rNnsUlZX7z1yPBoNSfWvoXwKhSAjGUhpBo9CZVJwadw=

+

+Name: org/eclipse/viatra/dse/base/DseIdPoolHelper.class

+SHA-256-Digest: 8wUkapQg0xNS3Vy/Mtv18N9dEB9ev/QiH1tYPzFtBN8=

+

+Name: about.html

+SHA-256-Digest: Qx53vUKBh4ByLG9I8uUS7GH8BTecG5s70WKYlnHc04k=

+

+Name: org/eclipse/viatra/dse/solutionstore/ISolutionFoundHandler.class

+SHA-256-Digest: bjBZdHvq37DxouRprrTxR0l8CWUCY+aw5JtccbEeAJg=

+

+Name: org/eclipse/viatra/dse/designspace/api/DesignSpace.class

+SHA-256-Digest: D51XZw1Z2bCk+PxzX7i8WpE64L9s64FoedEMxM0fSYA=

+

+Name: org/eclipse/viatra/dse/util/ValueComparableEObjectStringMap.clas

+ s

+SHA-256-Digest: VYf9HcY2IbUo2d1K+c2rKIFkxNIRFeEi9zr9s1Inc7o=

+

+Name: org/eclipse/viatra/dse/statecoding/StatecodingNodeType.class

+SHA-256-Digest: VUsDepoiER2/0o3aIE8uX08eOdXzvKBkfXPpPaow5yU=

+

+Name: org/eclipse/viatra/dse/api/strategy/interfaces/IStrategyFactory.

+ class

+SHA-256-Digest: K51RjSOSyMrj86BO/zgmo4kO83HgxKvrEGeOTo5WoVs=

+

+Name: org/eclipse/viatra/dse/base/ActivationCodesConflictSet$Activatio

+ nCodesMultiBiMap.class

+SHA-256-Digest: DEtZHFLUnrSZG5x15o2lTasPd5+ufqWCCQXg+YXGxQA=

+

+Name: org/eclipse/viatra/dse/statecoding/TheStateCoder.class

+SHA-256-Digest: 7iWoLYIXKNGjRgpIHZDuW3i8wBpV5OqO978Fg9WxEK8=

+

+Name: org/eclipse/viatra/dse/objectives/LeveledObjectivesHelper.class

+SHA-256-Digest: HYJ6Z75XEjy3UGBB00bv/GfxdOey+9MpGM5aJuFm5fM=

+

+Name: org/eclipse/viatra/dse/solutionstore/ModelSaverSolutionFoundHand

+ ler.class

+SHA-256-Digest: CmINEWESAe5ynUDWoc8YQQdsmBx1bRLNabbzmoxxsUg=

+

+Name: org/eclipse/viatra/dse/base/DseConflictSet.class

+SHA-256-Digest: boreOAKc8L3ZEts53PUwZiZ4l+8Em3aLeXDQBJZihbY=

+

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/META-INF/maven/org.eclipse.viatra/org.eclipse.viatra.dse/pom.properties b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/META-INF/maven/org.eclipse.viatra/org.eclipse.viatra.dse/pom.properties
new file mode 100644
index 00000000..33746c20
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/META-INF/maven/org.eclipse.viatra/org.eclipse.viatra.dse/pom.properties
@@ -0,0 +1,3 @@
+artifactId=org.eclipse.viatra.dse
+groupId=org.eclipse.viatra
+version=0.24.0-SNAPSHOT
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/META-INF/maven/org.eclipse.viatra/org.eclipse.viatra.dse/pom.xml b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/META-INF/maven/org.eclipse.viatra/org.eclipse.viatra.dse/pom.xml
new file mode 100644
index 00000000..4d50659f
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/META-INF/maven/org.eclipse.viatra/org.eclipse.viatra.dse/pom.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
+    xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>org.eclipse.viatra.parent.dse</artifactId>
+        <groupId>org.eclipse.viatra</groupId>
+        <version>0.24.0-SNAPSHOT</version>
+        <relativePath>../../../releng/org.eclipse.viatra.parent.dse/pom.xml</relativePath>
+    </parent>
+    <artifactId>org.eclipse.viatra.dse</artifactId>
+    <packaging>eclipse-plugin</packaging>
+</project>
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/about.html b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/about.html
new file mode 100644
index 00000000..4c69fcc0
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/about.html
@@ -0,0 +1,21 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
+<html>
+<head>
+<title>About</title>
+<meta http-equiv=Content-Type content="text/html; charset=ISO-8859-1">
+</head>
+<body lang="EN-US">
+<h2>About This Content</h2>
+ 
+<p>March 18, 2019</p>   
+<h3>License</h3>
+
+<p>The Eclipse Foundation makes available all content in this plug-in (&quot;Content&quot;).  Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
+Eclipse Public License Version 2.0 (&quot;EPL&quot;).  A copy of the EPL is available at <a href="http://www.eclipse.org/org/documents/epl-v20.php">http://www.eclipse.org/legal/epl-v20.html</a>.
+For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party (&quot;Redistributor&quot;) and different terms and conditions may
+apply to your use of any object code in the Content.  Check the Redistributor's license that was provided with the Content.  If no such license exists, contact the Redistributor.  Unless otherwise
+indicated below, the terms and conditions of the EPL still apply to any source code in the Content and such source code may be obtained at <a href="http://www.eclipse.org/">http://www.eclipse.org</a>.</p>
+</body>
+</html>
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/build.properties b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/build.properties
new file mode 100644
index 00000000..08373bf1
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/build.properties
@@ -0,0 +1,4 @@
+source.. = src/
+bin.includes = META-INF/,\
+               .,\
+               about.html
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/DSEException.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/DSEException.java
new file mode 100644
index 00000000..f0da19ed
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/DSEException.java
@@ -0,0 +1,47 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api;
+
+/**
+ * Represents a general runtime exception that happened during the execution of the design space exploration process.
+ * Problems that cause this exception are not recoverable within the scope of the design space exploration process.
+ */
+public class DSEException extends RuntimeException {
+
+    private static final long serialVersionUID = -8312212010574763824L;
+
+    /**
+     * @see RuntimeException#RuntimeException()
+     */
+    public DSEException() {
+        super();
+    }
+
+    /**
+     * @see RuntimeException#RuntimeException(String) 
+     */
+    public DSEException(String message) {
+        super(message);
+    }
+
+    /**
+     * @see RuntimeException#RuntimeException(String, Throwable)
+     */
+    public DSEException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * @see RuntimeException#RuntimeException(Throwable)
+     */
+    public DSEException(Throwable cause) {
+        super(cause);
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/DSETransformationRule.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/DSETransformationRule.java
new file mode 100644
index 00000000..8c3511ae
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/DSETransformationRule.java
@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api;
+
+import java.util.Objects;
+import java.util.function.Consumer;
+
+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.transformation.runtime.emf.rules.batch.BatchTransformationRule;
+
+/**
+ * An instance of this class is a specification of a graph transformation rule on a given metamodel. Such a rule
+ * consists of a left hand side (LHS), which is specified by an {@link IQuerySpecification} and a right hand side (RHS),
+ * which is specified by an {@link Consumer}.
+ * 
+ * @author Andras Szabolcs Nagy
+ * 
+ * @param <Match>
+ *            A VIATRA Query pattern match - left hand side of the rule
+ * @param <Matcher>
+ *            A VIATRA Query pattern matcher - left hand side of the rule
+ * @deprecated
+ */
+@Deprecated
+public class DSETransformationRule<Match extends IPatternMatch, Matcher extends ViatraQueryMatcher<Match>> extends
+        BatchTransformationRule<Match, Matcher> {
+
+    public DSETransformationRule(String name, IQuerySpecification<Matcher> querySpec,
+            Consumer<Match> action) {
+        super(name, querySpec, BatchTransformationRule.STATELESS_RULE_LIFECYCLE, action);
+
+        Objects.requireNonNull(name);
+        Objects.requireNonNull(querySpec);
+        Objects.requireNonNull(action);
+
+    }
+
+    public DSETransformationRule(IQuerySpecification<Matcher> querySpec,
+            Consumer<Match> action) {
+        this(querySpec.getFullyQualifiedName(), querySpec, action);
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/DesignSpaceExplorer.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/DesignSpaceExplorer.java
new file mode 100644
index 00000000..9cd6e68a
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/DesignSpaceExplorer.java
@@ -0,0 +1,622 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.log4j.BasicConfigurator;
+import org.apache.log4j.Level;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy;
+import org.eclipse.viatra.dse.base.DesignSpaceManager;
+import org.eclipse.viatra.dse.base.GlobalContext;
+import org.eclipse.viatra.dse.designspace.api.DesignSpace;
+import org.eclipse.viatra.dse.designspace.api.IDesignSpace;
+import org.eclipse.viatra.dse.objectives.IGlobalConstraint;
+import org.eclipse.viatra.dse.objectives.IObjective;
+import org.eclipse.viatra.dse.solutionstore.ISolutionNameProvider;
+import org.eclipse.viatra.dse.solutionstore.IdBasedSolutionNameProvider;
+import org.eclipse.viatra.dse.solutionstore.SolutionStore;
+import org.eclipse.viatra.dse.statecode.IStateCoder;
+import org.eclipse.viatra.dse.statecode.IStateCoderFactory;
+import org.eclipse.viatra.dse.statecoding.simple.SimpleStateCoderFactory;
+import org.eclipse.viatra.dse.visualizer.IDesignSpaceVisualizer;
+import org.eclipse.viatra.query.runtime.matchers.util.Preconditions;
+import org.eclipse.viatra.transformation.evm.api.resolver.ConflictResolver;
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule;
+
+/**
+ * <p>
+ * The {@link DesignSpaceExplorer} is the main API of the <b>Design Space Exploration</b> engine.
+ * </p>
+ * 
+ * <p>
+ * To parameterize the algorithm one must use the following methods after instantiating:
+ * <ul>
+ * <li>{@link #setInitialModel(EObject)} or it's overloads to set the starting model.</li>
+ * <li>{@link #addTransformationRule(BatchTransformationRule)} to define the transformations.</li> <li
+ * {@link #addObjective(IObjective)} to define the objective functions. Use the {@link Objectives} helper class for
+ * instantiating built-in, configurable objectives.</li>
+ * <li>{@link #startExploration(IStrategy)} or it's overloads to start an exploration with the given exploration
+ * strategy. Use the {@link Strategies} helper class for instantiating built-in, configurable exploration strategies.
+ * </li>
+ * </ul>
+ * </p>
+ * 
+ * <p>
+ * <b>Designs Space Exploration</b> is the process of finding a sequence (or sequences) of predefined transformation
+ * rules ("transitions") that, if applied in order on the starting model, results in a new model state that fulfills the
+ * hard (or goal) constraints and is near optimal with respect to the objectives.
+ * </p>
+ * 
+ * <p>
+ * An extension to this paradigm is the introduction of global constraints, which guarantees, that no sequence will be
+ * returned, which if executed, results in an intermediate model state that violates the specified global constraints,
+ * including the final state. You can add constraints by invoking {@link #addGlobalConstraint(IGlobalConstraint)}.
+ * </p>
+ * 
+ * @author Andras Szabolcs Nagy & Miklos Foldenyi
+ * 
+ */
+public class DesignSpaceExplorer {
+
+    private Notifier model;
+
+    private GlobalContext globalContext = new GlobalContext();
+
+    private final Logger logger = Logger.getLogger(this.getClass());
+
+    private Set<EPackage> metaModelPackages = new HashSet<EPackage>();
+
+    private static final String MODEL_NOT_YET_GIVEN = "The starting model is not given yet. Please call the setInitialModel method first.";
+
+    private boolean deepCopyModel;
+
+    /**
+     * <p>
+     * Creates a {@link DesignSpaceExplorer} object that is able to execute a design space exploration process.
+     * </p>
+     * 
+     * <p>
+     * By default the state coder used is the generic (not meta-model specific) {@link GraphHash}. You can provide your
+     * custom state coder by implementing the {@link IStateCoderFactory} and {@link IStateCoder} interfaces, and passing
+     * the former to the {@link #setStateCoderFactory(IStateCoderFactory)} method.
+     * 
+     */
+    public DesignSpaceExplorer() {
+        setDesignspace(new DesignSpace());
+    }
+
+    /**
+     * Adds a metamodel in the form of {@link EPackage}, which is needed for certain guidance.
+     * 
+     * @param metaModelPackage
+     */
+    public void addMetaModelPackage(EPackage metaModelPackage) {
+        metaModelPackages.add(metaModelPackage);
+    }
+
+    /**
+     * Defines the initial model of the exploration, and whether it is supposed to be used to execute the DSE process or
+     * it should be cloned. Please note, that in multithreaded mode any subsequent threads will be working on cloned
+     * models.
+     * 
+     * @param model
+     *            The root object of the EMF model.
+     * @param deepCopyModel
+     *            If it is set to true, the exploration will run on a cloned model.
+     */
+    public void setInitialModel(Notifier model, boolean deepCopyModel) {
+        this.model = model;
+        this.deepCopyModel = deepCopyModel;
+    }
+
+    /**
+     * Defines the initial model of the exploration. The model will be cloned, which is desired in most cases as the
+     * given model won't be changed.
+     * 
+     * @param model
+     *            The root object of the EMF model.
+     */
+    public void setInitialModel(Notifier model) {
+        setInitialModel(model, true);
+    }
+
+    /**
+     * Defines the initial model of the exploration. The given model won't be cloned, thus the exploration will modify
+     * it.
+     * 
+     * @param model
+     *            The root object of the EMF model. It won't be cloned.
+     */
+    public void setInitialModelUncloned(Notifier model) {
+        setInitialModel(model, false);
+    }
+
+    /**
+     * Adds a {@link BatchTransformationRule}.
+     * 
+     * @param rule
+     *            The transformationRule.
+     */
+    public void addTransformationRule(BatchTransformationRule<?, ?> rule) {
+        Preconditions.checkArgument(rule != null);
+        for (BatchTransformationRule<?, ?> rule2 : globalContext.getTransformations()) {
+            if (rule.getPrecondition().equals(rule2.getPrecondition())) {
+                throw new DSEException(
+                        "Two transformation rule ("
+                                + rule.getName()
+                                + "; "
+                                + rule2.getName()
+                                + ") uses the same LHS VIATRA Query pattern ("
+                                + rule.getPrecondition().getFullyQualifiedName()
+                                + "), which may lead to hash collision."
+                                + " Please wrap the pattern with an other pattern with the 'find' keyword (or duplicate the code), and use that for one of the rules LHS.");
+            }
+        }
+
+        globalContext.getTransformations().add(rule);
+    }
+
+    /**
+     * Adds a global constraint to the exploration process. Please see the {@link IGlobalConstraint} interface and its
+     * implementations for details.
+     * 
+     * @param constraint
+     *            The global constraint.
+     * @see IGlobalConstraint
+     */
+    public void addGlobalConstraint(IGlobalConstraint constraint) {
+        globalContext.getGlobalConstraints().add(constraint);
+    }
+
+    /**
+     * Adds an objective the the exploration process. Please see the {@link IObjective} interface and its
+     * implementations for details.
+     * 
+     * @param objective
+     *            The objective.
+     * @see IObjective
+     */
+    public void addObjective(IObjective objective) {
+        for (IObjective o : globalContext.getObjectives()) {
+            if (o.getName().equals(objective.getName())) {
+                throw new DSEException("Two objectives with the same name cannot be registered:" + o.getName());
+            }
+        }
+        globalContext.getObjectives().add(objective);
+    }
+
+    /**
+     * Sets a {@link IStateCoderFactory} for which will be used for creating {@link IStateCoder}s. The default
+     * implementation is the {@link SimpleStateCoderFactory}, which works well in most of the cases.
+     * 
+     * @param stateCoderFactory
+     *            The factory.
+     */
+    public final void setStateCoderFactory(IStateCoderFactory stateCoderFactory) {
+        globalContext.setStateCoderFactory(stateCoderFactory);
+    }
+
+    /**
+     * Defines the maximum processing threads that the design space exploration can use. Note, that this is only
+     * limiting the threads doing the actual calculation. By default this value will be set to the number of logical
+     * processors (including HyperThreading) in the computer, reported by {@link Runtime#availableProcessors()}.
+     * 
+     * @param maxNumberOfThreads
+     *            The number of maximum processing threads available to the design space exploration process.
+     */
+    public void setMaxNumberOfThreads(int maxNumberOfThreads) {
+        globalContext.getThreadPool().setMaximumPoolSize(maxNumberOfThreads);
+    }
+
+    /**
+     * Sets the {@link IDesignSpace} implementation that is to be used during the design space exploration process. By
+     * default, the {@link DesignSpace} implementation is used.
+     * 
+     * @param designspace
+     *            The {@link IDesignSpace} implementation.
+     */
+    public final void setDesignspace(IDesignSpace designspace) {
+        globalContext.setDesignSpace(designspace);
+    }
+
+    /**
+     * Sets the solution store for strategies. Please see the {@link SolutionStore} for how to configure it.
+     * 
+     * @param solutionStore
+     *            The parameterized {@link SolutionStore} implementation.
+     */
+    public void setSolutionStore(SolutionStore solutionStore) {
+        globalContext.setSolutionStore(solutionStore);
+    }
+
+    /**
+     * Starts the design space exploration. It returns only when the strategy decides to stop the execution.
+     * 
+     * @param strategy
+     *            The strategy of the exploration.
+     */
+    public void startExploration(IStrategy strategy) {
+        startExploration(strategy, true, -1);
+    }
+
+    /**
+     * Starts the design space exploration asynchronously. Completion of the process can be verified by calling
+     * {@link DesignSpaceExplorer#isDone()}.
+     * 
+     * @param strategy
+     *            The strategy of the exploration.
+     */
+    public void startExplorationAsync(IStrategy strategy) {
+        startExploration(strategy, false, -1);
+    }
+
+    /**
+     * Starts the design space exploration with a timeout. It returns only when the strategy decides to stop the
+     * execution or the given timeout is elapsed.
+     * 
+     * @param strategy
+     *            The strategy of the exploration.
+     * @param timeout
+     *            The number of milliseconds before the exploration is forced to stop.
+     * @return Returns true if the exploration stopped by the timeout.
+     */
+    public boolean startExplorationWithTimeout(IStrategy strategy, long timeout) {
+        return startExploration(strategy, true, timeout);
+    }
+
+    /**
+     * Starts the design space exploration asynchronously with a timeout. Completion of the process can be verified by
+     * calling {@link DesignSpaceExplorer#isDone()}.
+     * 
+     * @param strategy
+     *            The strategy of the exploration.
+     * @param timeout
+     *            The number of milliseconds before the exploration is forced to stop.
+     * @return Returns true if the exploration stopped by the timeout.
+     */
+    public boolean startExplorationAsyncWithTimeout(IStrategy strategy, long timeout) {
+        return startExploration(strategy, false, timeout);
+    }
+
+    /**
+     * Starts the design space exploration. If {@code waitForTermination} is true, then it returns only when the
+     * strategy decides to stop the execution or there was a timeout, otherwise when the exploration process is started
+     * it returns immediately. In this case, process completion can be verified by calling
+     * {@link DesignSpaceExplorer#isDone()}.
+     * 
+     * @param strategy
+     *            The strategy of the exploration.
+     * @param waitForTermination
+     *            True if the method must wait for the engine to stop, i.e. whether to start synchronously.
+     * @param timeout
+     *            The number of milliseconds before the exploration is forced to stop.
+     * @return Returns true if the exploration stopped by the timeout.
+     */
+    public boolean startExploration(IStrategy strategy, boolean waitForTermination, final long timeout) {
+        initExploration(strategy);
+
+        Timer timer = new Timer();
+        final AtomicBoolean wasTimeout = new AtomicBoolean(false);
+
+        if (timeout > 0) {
+            TimerTask timerTask = new TimerTask() {
+                @Override
+                public void run() {
+                    logger.info("Timeout, stopping threads...");
+                    globalContext.stopAllThreads();
+                    wasTimeout.set(true);
+                }
+            };
+            timer.schedule(timerTask, timeout);
+        }
+
+        if (waitForTermination) {
+            waitForTerminaition();
+            timer.cancel();
+        } else {
+            logger.info("Design space exploration started asynchronously.");
+        }
+
+        return wasTimeout.get();
+
+    }
+
+    private void initExploration(IStrategy strategy) {
+        Preconditions.checkArgument(model != null, MODEL_NOT_YET_GIVEN);
+        Preconditions.checkArgument(strategy != null, "A strategy must be given. Use the Strategies helper class.");
+        Preconditions.checkState(!globalContext.getTransformations().isEmpty(),
+                "At least one transformation rule must be added to start the exploration.");
+
+        if (globalContext.getStateCoderFactory() == null) {
+            if (getMetaModelPackages() == null || getMetaModelPackages().isEmpty()) {
+                throw new DSEException("Cannot initialize state coder."
+                        + " Please specifiy the EPackages your model uses with addMetaModelPackage(EPackage)");
+            }
+            globalContext.setStateCoderFactory(new SimpleStateCoderFactory(getMetaModelPackages()));
+        }
+
+        logger.info("DesignSpaceExplorer started exploration.");
+
+        if (deepCopyModel) {
+            globalContext.startFirstThread(strategy, model);
+        } else {
+            globalContext.startFirstThreadWithoutModelClone(strategy, model);
+        }
+    }
+
+    /**
+     * Returns all of the found {@link Solution}s, trajectories. Call it after
+     * {@link DesignSpaceExplorer#startExploration()}. Calling this while the process is running returns the solutions
+     * that have been found <b>so far</b>. The returned {@link Solution} objects may change internal state after they
+     * have been returned, if a shorter trajectory has been found to the referred state.
+     * 
+     * @return The found solutions.
+     */
+    public Collection<Solution> getSolutions() {
+        return globalContext.getSolutionStore().getSolutions();
+    }
+
+    /**
+     * Returns an arbitrary solution trajectory or null if the exploration failed to find any.
+     * 
+     * @return An arbitrary solution trajectory.
+     */
+    public SolutionTrajectory getArbitrarySolution() {
+        Collection<Solution> solutions = getSolutions();
+        if (solutions.isEmpty()) {
+            return null;
+        }
+        return solutions.iterator().next().getArbitraryTrajectory();
+    }
+
+    /**
+     * Returns the number of distinct states the exploration process has visited so far.
+     * 
+     * @return the number of distinct states.
+     */
+    public long getNumberOfStates() {
+        return globalContext.getDesignSpace().getNumberOfStates();
+    }
+
+    /**
+     * Returns the number of distinct transitions the exploration process has discovered (but not necessarily traversed)
+     * so far.
+     * 
+     * @return the number of distinct transitions.
+     */
+    public long getNumberOfTransitions() {
+        return globalContext.getDesignSpace().getNumberOfTransitions();
+    }
+
+    /**
+     * Returns the {@link EPackage}s, which were registered with the
+     * {@link DesignSpaceExplorer#addMetaModelPackage(EPackage)} method.
+     * 
+     * @return The set of meta model packages.
+     */
+    public Set<EPackage> getMetaModelPackages() {
+        return metaModelPackages;
+    }
+
+    /**
+     * Returns true if the {@link IExplorerThread strategy} decided to stop, and all the threads finished their work.
+     * 
+     * @return true if the process has finished, false otherwise.
+     */
+    public boolean isDone() {
+        return globalContext.isDone();
+    }
+
+    /**
+     * Returns the {@link GlobalContext} which holds the configurations such as rule, objectives, etc.
+     * 
+     * @return The global context.
+     */
+    public GlobalContext getGlobalContext() {
+        return globalContext;
+    }
+
+    /**
+     * Registers a design space visualizer. Please see the corresponding interface {@link IDesignSpaceVisualizer}.
+     * 
+     * @see IDesignSpaceVisualizer
+     * 
+     * @param visualizer
+     */
+    public void addDesignSpaceVisulaizer(IDesignSpaceVisualizer visualizer) {
+        globalContext.registerDesignSpaceVisualizer(visualizer);
+    }
+
+    /**
+     * Creates a string containing the state codes of all the found solutions and the found trajectories to these
+     * solutions with fitness values.
+     * 
+     * @return A pretty string with the solutions.
+     */
+    public String toStringSolutions() {
+        StringBuilder sb = new StringBuilder();
+        Collection<Solution> solutions = getSolutions();
+        sb.append("Number of solutions: ");
+        sb.append(solutions.size());
+        sb.append("\n");
+        for (Solution solution : solutions) {
+            sb.append("Solution: ");
+            sb.append(solution.getStateCode());
+            sb.append("\n");
+            for (SolutionTrajectory trajectory : solution.getTrajectories()) {
+                sb.append("  ");
+                sb.append(trajectory.toPrettyString());
+                sb.append("\n");
+            }
+        }
+        return sb.toString();
+    }
+
+    /**
+     * A conflict resolver can filter rule activations the DSE engine will see. The primary use of this is symmetry
+     * reduction. This function is subject to change for better API.
+     * 
+     * @param conflictResolver
+     */
+    public void setConflictResolver(ConflictResolver conflictResolver) {
+        globalContext.setConflictResolver(conflictResolver);
+    }
+
+    /**
+     * Enumeration for different use cases of logging, including:
+     * <ul>
+     * <li>OFF - no error messages.</li>
+     * <li>WARN - only error and warn messages.</li>
+     * <li>BASIC - logs basic information on how the exploration is going.</li>
+     * <li>VERBOSE_STRATEGY - logs everything the exploration strategy is prepared for.</li>
+     * <li>VERBOSE_FULL - logs every transformation.</li>
+     * </ul>
+     * 
+     * @author Andras Szabolcs Nagy
+     *
+     */
+    public enum DseLoggingLevel {
+        OFF, WARN, BASIC, VERBOSE_STRATEGY, VERBOSE_FULL
+    }
+
+    /**
+     * Changes the level of logging. See {@link DseLoggingLevel} for details.
+     * 
+     * @param dseLoggingLevel
+     */
+    public static void turnOnLogging(DseLoggingLevel dseLoggingLevel) {
+        switch (dseLoggingLevel) {
+        case OFF:
+            Logger.getLogger(DesignSpaceExplorer.class).setLevel(Level.OFF);
+            Logger.getLogger(IStrategy.class).setLevel(Level.OFF);
+            Logger.getLogger(DesignSpaceManager.class).setLevel(Level.OFF);
+            break;
+        case WARN:
+            Logger.getLogger(DesignSpaceExplorer.class).setLevel(Level.WARN);
+            Logger.getLogger(IStrategy.class).setLevel(Level.WARN);
+            Logger.getLogger(DesignSpaceManager.class).setLevel(Level.WARN);
+            break;
+        case BASIC:
+            Logger.getLogger(DesignSpaceExplorer.class).setLevel(Level.INFO);
+            Logger.getLogger(IStrategy.class).setLevel(Level.INFO);
+            Logger.getLogger(DesignSpaceManager.class).setLevel(Level.WARN);
+            break;
+        case VERBOSE_STRATEGY:
+            Logger.getLogger(DesignSpaceExplorer.class).setLevel(Level.DEBUG);
+            Logger.getLogger(IStrategy.class).setLevel(Level.DEBUG);
+            Logger.getLogger(DesignSpaceManager.class).setLevel(Level.WARN);
+            break;
+        case VERBOSE_FULL:
+            Logger.getLogger(DesignSpaceExplorer.class).setLevel(Level.DEBUG);
+            Logger.getLogger(IStrategy.class).setLevel(Level.DEBUG);
+            Logger.getLogger(DesignSpaceManager.class).setLevel(Level.DEBUG);
+            break;
+        default:
+            throw new DSEException("Not supported logging level.");
+        }
+    }
+
+    /**
+     * Changes the level of logging. See {@link DseLoggingLevel} for details.
+     * 
+     * Also configures a basic console appender for log4j.
+     * 
+     * @param dseLoggingLevel
+     */
+    public static void turnOnLoggingWithBasicConfig(DseLoggingLevel dseLoggingLevel) {
+        BasicConfigurator.configure();
+        Logger.getRootLogger().setLevel(Level.WARN);
+        turnOnLogging(dseLoggingLevel);
+    }
+
+    /**
+     * Stops the exploration and waits for termination. It has no effect if the exploration is already terminated or not
+     * even started.
+     */
+    public void stopExploration() {
+        if (globalContext.isDone()) {
+            logger.info("Cannot stop exploration - design space exploration has already finished.");
+        } else if (globalContext.isNotStarted()) {
+            logger.info("Cannot stop exploration - design space exploration has not been started.");
+        } else {
+            globalContext.stopAllThreads();
+            waitForTerminaition();
+        }
+    }
+
+    /**
+     * Stops the exploration asynchronously. It has no effect if the exploration is already terminated or not even
+     * started.
+     */
+    public void stopExplorationAsync() {
+        if (globalContext.isDone()) {
+            logger.info("Cannot stop exploration - design space exploration has already finished.");
+        } else if (globalContext.isNotStarted()) {
+            logger.info("Cannot stop exploration - design space exploration has not been started.");
+        } else {
+            globalContext.stopAllThreads();
+        }
+    }
+
+    /**
+     * Waits for termination.
+     */
+    public void waitForTerminaition() {
+        globalContext.waitForTermination();
+    }
+
+    /**
+     * Serializes all the found solutions by transforming the given initial model.
+     * </p>Files will be named <code>solution[id].xmi</code>.
+     * @param model The initial model.
+     */
+    public void saveModels(Notifier model) {
+        this.saveModels(model, "solution", "xmi");
+    }
+
+    /**
+     * Serializes all the found solutions by transforming the given initial model.
+     * </p>Files will be named <code>solution[id].[extension]</code>.
+     * @param model The initial model.
+     * @param extension The extension of the omitted file.
+     */
+    public void saveModels(Notifier model, String extension) {
+        this.saveModels(model, "solution", extension);
+    }
+
+    /**
+     * Serializes all the found solutions by transforming the given initial model.
+     * </p>Files will be named <code>[fileNamePrefix][id].[extension]</code>.
+     * @param model The initial model.
+     * @param fileNamePrefix The prefix (optionally including a file path) of the omitted file.
+     * @param extension The extension of the omitted file.
+     */
+    public void saveModels(Notifier model, String fileNamePrefix, String extension) {
+        globalContext.getSolutionStore().saveModels(model, new IdBasedSolutionNameProvider(fileNamePrefix, extension));
+    }
+
+    /**
+     * Serializes all the found solutions by transforming the given initial model.
+     * </p>Files will be named using the {@link ISolutionNameProvider}.
+     * @param model The initial model.
+     */
+    public void saveModels(Notifier model, ISolutionNameProvider solutionNameProvider) {
+        globalContext.getSolutionStore().saveModels(model, solutionNameProvider);
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/Objectives.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/Objectives.java
new file mode 100644
index 00000000..3b375fac
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/Objectives.java
@@ -0,0 +1,153 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api;
+
+import org.eclipse.viatra.dse.objectives.impl.CompositeObjective;
+import org.eclipse.viatra.dse.objectives.impl.ConstraintsObjective;
+import org.eclipse.viatra.dse.objectives.impl.AlwaysSatisfiedDummyHardObjective;
+import org.eclipse.viatra.dse.objectives.impl.DepthHardObjective;
+import org.eclipse.viatra.dse.objectives.impl.NeverSatisfiedDummyHardObjective;
+import org.eclipse.viatra.dse.objectives.impl.NoRuleActivationsHardObjective;
+import org.eclipse.viatra.dse.objectives.impl.TrajectoryCostSoftObjective;
+
+/**
+ * 
+ * Helper class for creating built-in objectives.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class Objectives {
+
+    private Objectives() {
+    }
+
+    /**
+     * This objective uses VIATRA Queries to calculate fitness and/or goal constraints. Use methods on the returned
+     * objective to configure it.
+     * 
+     * @param name
+     * @return The objective.
+     * @see ConstraintsObjective
+     */
+    public static ConstraintsObjective createConstraintsObjective(String name) {
+        return new ConstraintsObjective(name);
+    }
+
+    /**
+     * This objective calculates fitness on the trajectory by adding either fix costs to the rules, or by calculating
+     * custom fitness on activation of rules.
+     * 
+     * @param name
+     * @return The objective.
+     * @see TrajectoryCostSoftObjective
+     */
+    public static TrajectoryCostSoftObjective createTrajcetoryCostObjective(String name) {
+        return new TrajectoryCostSoftObjective(name);
+    }
+
+    /**
+     * This objective adds a goal constraint that a solution state should not have any activations.
+     * 
+     * @return The objective.
+     * @see NoRuleActivationsHardObjective
+     */
+    public static NoRuleActivationsHardObjective createNoRuleActivationsHardConstraint() {
+        return new NoRuleActivationsHardObjective();
+    }
+
+    /**
+     * This objective adds a goal constraint that a solution state should not have any activations.
+     * 
+     * @param name
+     * @return The objective.
+     * @see NoRuleActivationsHardObjective
+     */
+    public static NoRuleActivationsHardObjective createNoRuleActivationsHardConstraint(String name) {
+        return new NoRuleActivationsHardObjective(name);
+    }
+
+    /**
+     * This objective can combine the calculated fitness value of other objectives. Weights are supported.
+     * 
+     * @param name
+     * @return The objective.
+     * @see NoRuleActivationsHardObjective
+     */
+    public static CompositeObjective createCompositeObjective(String name) {
+        return new CompositeObjective(name);
+    }
+
+    /**
+     * This hard objective is fulfilled in any circumstances. Use it if all states should be regarded as a valid
+     * solution.
+     * 
+     * @return The objective.
+     * @see AlwaysSatisfiedDummyHardObjective
+     */
+    public static AlwaysSatisfiedDummyHardObjective createAlwaysSatisfiedDummyHardObjective() {
+        return new AlwaysSatisfiedDummyHardObjective();
+    }
+
+    /**
+     * This hard objective is fulfilled in any circumstances. Use it if all states should be regarded as a valid
+     * solution.
+     * 
+     * @param name
+     * @return The objective.
+     * @see AlwaysSatisfiedDummyHardObjective
+     */
+    public static AlwaysSatisfiedDummyHardObjective createDummyHardObjective(String name) {
+        return new AlwaysSatisfiedDummyHardObjective(name);
+    }
+
+    /**
+     * This hard objective is never fulfilled. Use it if all states should be regarded as an invalid solution.
+     * 
+     * @return The objective.
+     * @see AlwaysSatisfiedDummyHardObjective
+     */
+    public static NeverSatisfiedDummyHardObjective createNeverSatisfiedDummyHardObjective() {
+        return new NeverSatisfiedDummyHardObjective();
+    }
+
+    /**
+     * This hard objective is never fulfilled. Use it if all states should be regarded as an invalid solution.
+     * 
+     * @return The objective.
+     * @see AlwaysSatisfiedDummyHardObjective
+     */
+    public static NeverSatisfiedDummyHardObjective createNeverSatisfiedDummyHardObjective(String name) {
+        return new NeverSatisfiedDummyHardObjective(name);
+    }
+
+    /**
+     * This hard objective is fulfilled if the length of the trajectory is in the specified interval (inclusive). Use
+     * {@link DepthHardObjective#withMinDepth(int)} and {@link DepthHardObjective#withMaxDepth(int)} to configure.
+     * 
+     * @return The objective.
+     * @see DepthHardObjective
+     */
+    public static DepthHardObjective createDepthHardObjective() {
+        return new DepthHardObjective();
+    }
+
+    /**
+     * This hard objective is fulfilled if the length of the trajectory is in the specified interval (inclusive). Use
+     * {@link DepthHardObjective#withMinDepth(int)} and {@link DepthHardObjective#withMaxDepth(int)} to configure.
+     * 
+     * @param name
+     * @return The objective.
+     * @see DepthHardObjective
+     */
+    public static DepthHardObjective createDepthHardObjective(String name) {
+        return new DepthHardObjective(name);
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/Solution.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/Solution.java
new file mode 100644
index 00000000..b776db7a
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/Solution.java
@@ -0,0 +1,60 @@
+/*******************************************************************************

+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro

+ * This program and the accompanying materials are made available under the

+ * terms of the Eclipse Public License v. 2.0 which is available at

+ * http://www.eclipse.org/legal/epl-v20.html.

+ * 

+ * SPDX-License-Identifier: EPL-2.0

+ *******************************************************************************/

+package org.eclipse.viatra.dse.api;

+

+import java.util.Collection;

+import java.util.HashSet;

+import java.util.Iterator;

+import java.util.Set;

+

+public class Solution {

+

+    private Set<SolutionTrajectory> trajectories;

+    private final Object stateId;

+

+    public Solution(Object stateId, SolutionTrajectory trajectory) {

+        this.stateId = stateId;

+        trajectories = new HashSet<>();

+        trajectories.add(trajectory);

+    }

+

+    public void addTrajectory(SolutionTrajectory trajectory) {

+        trajectories.add(trajectory);

+    }

+

+    public SolutionTrajectory getArbitraryTrajectory() {

+        return trajectories.iterator().next();

+    }

+

+    public SolutionTrajectory getShortestTrajectory() {

+        Iterator<SolutionTrajectory> iterator = trajectories.iterator();

+        SolutionTrajectory shortestTrajecotry = iterator.next();

+        int minSize = shortestTrajecotry.getTrajectoryLength();

+

+        while (iterator.hasNext()) {

+            SolutionTrajectory traj = iterator.next();

+            int size = traj.getTrajectoryLength();

+            if (size < minSize) {

+                shortestTrajecotry = traj;

+                minSize = size;

+            }

+        }

+

+        return shortestTrajecotry;

+    }

+

+    public Collection<SolutionTrajectory> getTrajectories() {

+        return trajectories;

+    }

+

+    public Object getStateCode() {

+        return stateId;

+    }

+

+}

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/SolutionTrajectory.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/SolutionTrajectory.java
new file mode 100644
index 00000000..500dd7d2
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/SolutionTrajectory.java
@@ -0,0 +1,345 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Consumer;
+
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.edit.command.ChangeCommand;
+import org.eclipse.emf.edit.domain.EditingDomain;
+import org.eclipse.viatra.dse.base.DseIdPoolHelper;
+import org.eclipse.viatra.dse.designspace.api.IBacktrackListener;
+import org.eclipse.viatra.dse.objectives.Fitness;
+import org.eclipse.viatra.dse.statecode.IStateCoder;
+import org.eclipse.viatra.dse.statecode.IStateCoderFactory;
+import org.eclipse.viatra.dse.util.EMFHelper;
+import org.eclipse.viatra.query.runtime.api.AdvancedViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+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.viatra.query.runtime.matchers.ViatraQueryRuntimeException;
+import org.eclipse.viatra.query.runtime.matchers.util.Preconditions;
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule;
+
+import com.google.common.util.concurrent.UncheckedExecutionException;
+
+/**
+ * A SolutionTrajectory represents a trajectory (i.e. sequence of transformation
+ * rule applications), which can transform the initial model to a desired state.
+ * An instance of this class holds the the actual rule sequence and the
+ * corresponding activation codes. Furthermore it can be used to perform the
+ * transformation on a given model (if possible).
+ * <p>
+ * It is also possible to undo the transformation if initialized with an editing
+ * domain.
+ * <p>
+ * The instance of this class can be reused for different models.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class SolutionTrajectory {
+
+        private final List<Object> activationCodes;
+        private final List<BatchTransformationRule<?, ?>> transformationRules;
+        private final IStateCoderFactory stateCoderFactory;
+        private Fitness fitness;
+        private Solution solution;
+
+        private ViatraQueryEngine engine;
+        private Notifier model;
+        private EditingDomain editingDomain;
+        private IStateCoder stateCoder;
+        private IBacktrackListener listener;
+
+        private int currentIndex;
+
+        public SolutionTrajectory(final List<Object> activationCodes,
+                        final List<BatchTransformationRule<?, ?>> transformationRules, final IStateCoderFactory stateCoderFactory,
+                        final IBacktrackListener backtrackListener) {
+                Objects.requireNonNull(transformationRules, "Parameter transformationRules cannot be null!");
+                Objects.requireNonNull(stateCoderFactory, "Parameter stateCoderFactory cannot be null!");
+                Objects.requireNonNull(activationCodes, "Parameter activations cannot be null!");
+                Preconditions.checkState(transformationRules.size() == activationCodes.size(),
+                                "The two List parameters must be the same in size.");
+
+                this.activationCodes = activationCodes;
+                this.transformationRules = transformationRules;
+                this.stateCoderFactory = stateCoderFactory;
+                this.listener = backtrackListener;
+                currentIndex = 0;
+        }
+
+        /**
+         * Initialize this SolutionTrajectory for transforming the model along the
+         * trajectory.
+         * 
+         * @param model The model.
+         * @throws ViatraQueryRuntimeException If the VIATRA Query fails to initialize.
+         */
+        public void setModel(Notifier model) {
+                editingDomain = null;
+                EMFScope scope = new EMFScope(model);
+                this.engine = ViatraQueryEngine.on(scope);
+                this.model = model;
+                stateCoder = stateCoderFactory.createStateCoder();
+                stateCoder.init(model);
+                currentIndex = 0;
+                DseIdPoolHelper.INSTANCE.disposeByThread();
+                DseIdPoolHelper.INSTANCE.registerRules(rule -> {
+                        int id = 0;
+                        for (BatchTransformationRule<?, ?> r : transformationRules.subList(0, currentIndex)) {
+                                if (r.equals(rule)) {
+                                        id++;
+                                }
+                        }
+                        return id;
+                }, new HashSet<BatchTransformationRule<?, ?>>(transformationRules));
+        }
+
+        /**
+         * Initialize this SolutionTrajectory for transforming the given model along the
+         * trajectory.
+         * <p>
+         * The transformation will be reversible by creating an {@link EditingDomain} on
+         * the model.
+         * 
+         * @param modelRoot The root of the model.
+         * @throws ViatraQueryRuntimeException If the VIATRA Query fails to initialize.
+         */
+        public void setModelWithEditingDomain(Notifier modelRoot) {
+                setModel(modelRoot);
+                editingDomain = EMFHelper.createEditingDomain(model);
+        }
+
+        /**
+         * Transforms the given model along the trajectory.
+         * 
+         * @param modelRoot The root of the model.
+         * @throws ViatraQueryRuntimeException If the VIATRA Query fails to initialize.
+         */
+        public void doTransformation(Notifier modelRoot) {
+                setModel(modelRoot);
+                doTransformation();
+        }
+
+        /**
+         * Transforms the given model along the trajectory.
+         * <p>
+         * The transformation will be reversible by creating an {@link EditingDomain} on
+         * the model.
+         * 
+         * @param modelRoot The root of the model.
+         * @throws ViatraQueryRuntimeException If the VIATRA Query fails to initialize.
+         */
+        public void doTransformationUndoable(Notifier modelRoot) {
+                setModelWithEditingDomain(modelRoot);
+                doTransformation();
+        }
+
+        /**
+         * Transforms the given model along the trajectory. To initialize the model call
+         * the {@link SolutionTrajectory#setModel(Notifier)} method.
+         * 
+         * @throws Exception                   If the activation to fire is not found.
+         *                                     Possible problems: wrong model, bad state
+         *                                     serializer.
+         * @throws ViatraQueryRuntimeException If the VIATRA Query fails to initialize.
+         */
+        public void doTransformation() {
+                while (doNextTransformation())
+                        ;
+        }
+
+        /**
+         * Transforms the given model by one step to the solution (makes one step in the
+         * trajectory). To initialize the model call the
+         * {@link SolutionTrajectory#setModel(Notifier)} method.
+         * 
+         * @throws ViatraQueryRuntimeException
+         */
+        public boolean doNextTransformation() {
+                if (currentIndex >= activationCodes.size()) {
+                        return false;
+                } else {
+                        doNextTransformation(currentIndex);
+                        currentIndex++;
+                        return true;
+                }
+        }
+
+        @SuppressWarnings("unchecked")
+        private void doNextTransformation(int index) {
+                Objects.requireNonNull(model, "The model cannot be null! Use the setModel method.");
+
+                // cast for the ".process(match)" method.
+                BatchTransformationRule<?, ?> tr = transformationRules.get(index);
+                Object activationCode = activationCodes.get(index);
+
+                ViatraQueryMatcher<?> matcher = tr.getPrecondition().getMatcher(engine);
+
+                boolean isActivationFound = false;
+                for (final IPatternMatch match : matcher.getAllMatches()) {
+                        Object matchHash = stateCoder.createActivationCode(match);
+                        if (matchHash.equals(activationCode)) {
+                                @SuppressWarnings("rawtypes")
+                                final Consumer action = tr.getAction();
+
+                                if (editingDomain == null) {
+                                        action.accept(match);
+                                } else {
+                                        ChangeCommand cc = new ChangeCommand(model) {
+                                                @Override
+                                                protected void doExecute() {
+                                                        action.accept(match);
+                                                }
+                                        };
+                                        long start = System.nanoTime();
+                                        try {
+                                                ((AdvancedViatraQueryEngine) engine).delayUpdatePropagation(() -> {
+                                                        editingDomain.getCommandStack().execute(cc);
+                                                        return null;
+                                                });
+                                        } catch (InvocationTargetException e) {
+                                                throw new RuntimeException(e);
+                                        }
+                                        listener.forwardWorked(System.nanoTime() - start);
+                                }
+
+                                isActivationFound = true;
+                                break;
+                        }
+                }
+                if (!isActivationFound) {
+                        throw new UncheckedExecutionException(
+                                        "Activation was not found for transformation! Possible cause: wrong model, bad state coder. index: "
+                                                        + index + " Activation code: " + activationCode,
+                                        null);
+                }
+        }
+
+        /**
+         * Call this method to undo the last transformation.
+         * 
+         * @return True, if it was successful.
+         */
+        public boolean undoLastTransformation() {
+                Objects.requireNonNull(editingDomain, "To be able to undo the transformation initialize with editing domain.");
+                long start = System.nanoTime();
+                boolean result;
+                
+                if (currentIndex > 0) {
+                        try {
+                                ((AdvancedViatraQueryEngine) engine).delayUpdatePropagation(() -> {
+                                        editingDomain.getCommandStack().undo();
+                                        return null;
+                                });
+                        } catch (InvocationTargetException e) {
+                                throw new RuntimeException(e);
+                        }
+                        currentIndex--;
+                        result = true;
+                }
+                result = false;
+                listener.backtrackWorked(System.nanoTime() - start);
+                return result;
+        }
+
+        /**
+         * Call this method to undo the transformation.
+         */
+        public void undoTransformation() {
+                while (undoLastTransformation())
+                        ;
+        }
+
+        public List<Object> getActivationCodes() {
+                return activationCodes;
+        }
+
+        public List<BatchTransformationRule<?, ?>> getTransformationRules() {
+                return transformationRules;
+        }
+
+        public IStateCoderFactory getStateCoderFactory() {
+                return stateCoderFactory;
+        }
+
+        public ViatraQueryEngine getEngine() {
+                return engine;
+        }
+
+        public Notifier getModel() {
+                return model;
+        }
+
+        public IStateCoder getStateCoder() {
+                return stateCoder;
+        }
+
+        public int getCurrentIndex() {
+                return currentIndex;
+        }
+
+        public int getTrajectoryLength() {
+                return activationCodes.size();
+        }
+
+        public Fitness getFitness() {
+                return fitness;
+        }
+
+        public void setFitness(Fitness fitness) {
+                this.fitness = fitness;
+        }
+
+        public String toPrettyString() {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Fitness: ");
+                sb.append(fitness.toString());
+                sb.append(" | Trajectory (");
+                sb.append(activationCodes.size());
+                sb.append("): ");
+                for (Object object : activationCodes) {
+                        sb.append(object.toString());
+                        sb.append(" | ");
+                }
+                return sb.toString();
+        }
+
+        @Override
+        public int hashCode() {
+                return activationCodes.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (this == obj) {
+                        return true;
+                }
+                if (obj instanceof SolutionTrajectory) {
+                        SolutionTrajectory that = (SolutionTrajectory) obj;
+                        return activationCodes.equals(that.activationCodes);
+                }
+                return false;
+        }
+
+        public Solution getSolution() {
+                return solution;
+        }
+
+        public void setSolution(Solution solution) {
+                this.solution = solution;
+        }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/Strategies.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/Strategies.java
new file mode 100644
index 00000000..ed7a90da
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/Strategies.java
@@ -0,0 +1,123 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api;
+
+import org.eclipse.viatra.dse.api.strategy.impl.BestFirstStrategy;
+import org.eclipse.viatra.dse.api.strategy.impl.BreadthFirstStrategy;
+import org.eclipse.viatra.dse.api.strategy.impl.DepthFirstStrategy;
+import org.eclipse.viatra.dse.api.strategy.impl.FixedPriorityStrategy;
+import org.eclipse.viatra.dse.api.strategy.impl.HillClimbingStrategy;
+import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy;
+
+/**
+ * Helper class for instantiating strategies. To implement a new strategy use the {@link IStrategy} interface.
+ * 
+ * @author Andras Szabolcs Nagy
+ * 
+ */
+public final class Strategies {
+
+    private Strategies() {
+    }
+
+    /**
+     * Creates a depth-first search exploration strategy without a depth limit.
+     * 
+     * @return The strategy.
+     * @see DepthFirstStrategy
+     */
+    public static DepthFirstStrategy createDfsStrategy() {
+        return new DepthFirstStrategy();
+    }
+
+    /**
+     * Creates a depth-first search exploration strategy with a depth limit. A negative depth limit means no
+     * depth limit, zero means that it will check the initial state.
+     * 
+     * @param depthLimit
+     * @return The strategy.
+     * @see DepthFirstStrategy
+     */
+    public static DepthFirstStrategy createDfsStrategy(int depthLimit) {
+        return new DepthFirstStrategy(depthLimit);
+    }
+
+    /**
+     * Creates a fixed priority exploration strategy without a depth limit. It is a depth-first search exploration
+     * strategy but from a current state it only explores the activations with the highest priority. Priorities can be
+     * defined on the strategy itself.
+     * 
+     * @return The strategy.
+     * @see FixedPriorityStrategy
+     */
+    public static FixedPriorityStrategy createFixedPriorityStrategy() {
+        return createFixedPriorityStrategy(-1);
+    }
+
+    /**
+     * Creates a fixed priority exploration strategy with a depth limit, where a zero or negative depth limit means no
+     * depth limit. It is a depth-first search exploration strategy but from a current state it only explores the
+     * activations with the highest priority. Priorities can be defined on the strategy itself.
+     * 
+     * @param depthLimit
+     * @return The strategy.
+     * @see FixedPriorityStrategy
+     */
+    public static FixedPriorityStrategy createFixedPriorityStrategy(int depthLimit) {
+        return new FixedPriorityStrategy().withDepthLimit(depthLimit);
+    }
+
+    /**
+     * Creates a breadth-first search exploration strategy without a depth limit.
+     * 
+     * @return The strategy.
+     * @see BreadthFirstStrategy
+     */
+    public static BreadthFirstStrategy createBfsStrategy() {
+        return new BreadthFirstStrategy();
+    }
+
+    /**
+     * Creates a breadth-first search exploration strategy with a depth limit. A zero or negative depth limit means no
+     * depth limit.
+     * 
+     * @param depthLimit
+     * @return The strategy.
+     * @see BreadthFirstStrategy
+     */
+    public static BreadthFirstStrategy createBfsStrategy(int depthLimit) {
+        return new BreadthFirstStrategy(depthLimit);
+    }
+
+    /**
+     * Creates a hill climbing exploration strategy. By default, it explores all neighborhood states and chooses the
+     * best one to continue with until all neighborhood states are dominated by the current state. Other options are
+     * available on the strategy.
+     * 
+     * @return The strategy.
+     * @see HillClimbingStrategy
+     */
+    public static HillClimbingStrategy creatHillClimbingStrategy() {
+        return new HillClimbingStrategy();
+    }
+
+    /**
+     * See {@link BestFirstStrategy}.
+     */
+    public static BestFirstStrategy createBestFirstStrategy() {
+        return new BestFirstStrategy();
+    }
+
+    /**
+     * See {@link BestFirstStrategy}.
+     */
+    public static BestFirstStrategy createBestFirstStrategy(int depthLimit) {
+        return new BestFirstStrategy(depthLimit);
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/BestFirstStrategy.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/BestFirstStrategy.java
new file mode 100644
index 00000000..fe5604a1
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/BestFirstStrategy.java
@@ -0,0 +1,228 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api.strategy.impl;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.PriorityQueue;
+
+import org.apache.log4j.Logger;
+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.SolutionStore;
+
+/**
+ * This exploration strategy eventually explorers the whole design space but goes in the most promising directions
+ * first, based on the {@link Fitness}.
+ * 
+ * There are a few parameter to tune such as
+ * <ul>
+ * <li>maximum depth</li>
+ * <li>continue the exploration from a state that satisfies the hard objectives (the default that it will
+ * backtrack),</li>
+ * <li>whether to continue the exploration from the newly explored state if it is at least equally good than the
+ * previous one or only if it is better (default is "at least equally good").</li>
+ * </ul>
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class BestFirstStrategy implements IStrategy {
+
+    private ThreadContext context;
+    private SolutionStore solutionStore;
+
+    private int maxDepth;
+    private boolean isInterrupted = false;
+    private boolean backTrackIfSolution = true;
+    private boolean onlyBetterFirst = false;
+
+    private PriorityQueue<TrajectoryWithFitness> trajectoiresToExplore;
+    private Logger logger = Logger.getLogger(IStrategy.class);
+
+    private static class TrajectoryWithFitness {
+
+        public Object[] trajectory;
+        public Fitness fitness;
+
+        public TrajectoryWithFitness(Object[] trajectory, Fitness fitness) {
+            super();
+            this.trajectory = trajectory;
+            this.fitness = fitness;
+        }
+
+        @Override
+        public String toString() {
+            return Arrays.toString(trajectory) + fitness.toString();
+        }
+
+    }
+
+    /**
+     * Creates a new best-first search algorithm without depth limit.
+     */
+    public BestFirstStrategy() {
+        this(-1);
+    }
+
+    /**
+     * Creates a new best-first search algorithm with depth limit.
+     * 
+     * @param maxDepth
+     *            A negative <code>maxDepth</code> means no depth limit, zero means the checking of the initial state.
+     */
+    public BestFirstStrategy(int maxDepth) {
+        if (maxDepth < 0) {
+            this.maxDepth = Integer.MAX_VALUE;
+        } else {
+            this.maxDepth = maxDepth;
+        }
+    }
+
+    public BestFirstStrategy continueIfHardObjectivesFulfilled() {
+        backTrackIfSolution = false;
+        return this;
+    }
+
+    public BestFirstStrategy goOnOnlyIfFitnessIsBetter() {
+        onlyBetterFirst = true;
+        return this;
+    }
+
+    @Override
+    public void initStrategy(ThreadContext context) {
+        this.context = context;
+        this.solutionStore = context.getGlobalContext().getSolutionStore();
+        final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper();
+
+        trajectoiresToExplore = new PriorityQueue<TrajectoryWithFitness>(11,
+                (o1, o2) -> objectiveComparatorHelper.compare(o2.fitness, o1.fitness));
+    }
+
+    @Override
+    public void explore() {
+        final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper();
+
+        boolean globalConstraintsAreSatisfied = context.checkGlobalConstraints();
+        if (!globalConstraintsAreSatisfied) {
+            logger.info("Global contraint is not satisifed in the first state. Terminate.");
+            return;
+        }
+
+        final Fitness firstFittness = context.calculateFitness();
+        if (firstFittness.isSatisifiesHardObjectives()) {
+            context.newSolution();
+            logger.info("First state is a solution. Terminate.");
+            return;
+        }
+
+        if (maxDepth == 0) {
+            return;
+        }
+
+        final Object[] firstTrajectory = context.getTrajectory().toArray(new Object[0]);
+        TrajectoryWithFitness currentTrajectoryWithFittness = new TrajectoryWithFitness(firstTrajectory, firstFittness);
+        trajectoiresToExplore.add(currentTrajectoryWithFittness);
+
+        mainLoop: while (!isInterrupted) {
+
+            if (currentTrajectoryWithFittness == null) {
+                if (trajectoiresToExplore.isEmpty()) {
+                    logger.debug("State space is fully traversed.");
+                    return;
+                } else {
+                    currentTrajectoryWithFittness = trajectoiresToExplore.element();
+                    if (logger.isDebugEnabled()) {
+                        logger.debug("New trajectory is chosen: " + currentTrajectoryWithFittness);
+                    }
+                    context.getDesignSpaceManager().executeTrajectoryWithMinimalBacktrackWithoutStateCoding(currentTrajectoryWithFittness.trajectory);
+                }
+            }
+
+            Collection<Object> activationIds = context.getUntraversedActivationIds();
+            Iterator<Object> iterator = activationIds.iterator();
+
+            while (!isInterrupted && iterator.hasNext()) {
+                final Object nextActivation = iterator.next();
+                if (!iterator.hasNext()) {
+                    logger.debug("Last untraversed activation of the state.");
+                    trajectoiresToExplore.remove(currentTrajectoryWithFittness);
+                }
+
+                if (logger.isDebugEnabled()) {
+                    logger.debug("Executing new activation: " + nextActivation);
+                }
+                context.executeAcitvationId(nextActivation);
+                if (context.isCurrentStateAlreadyTraversed()) {
+                    logger.info("The new state is already visited.");
+                    context.backtrack();
+                } else if (!context.checkGlobalConstraints()) {
+                    logger.debug("Global contraint is not satisifed.");
+                    context.backtrack();
+                } else {
+                    final Fitness nextFitness = context.calculateFitness();
+                    if (nextFitness.isSatisifiesHardObjectives()) {
+                        solutionStore.newSolution(context);
+                        logger.debug("Found a solution.");
+                        if (backTrackIfSolution) {
+                            context.backtrack();
+                            continue;
+                        }
+                    }
+                    if (context.getDepth() >= maxDepth) {
+                        logger.debug("Reached max depth.");
+                        context.backtrack();
+                        continue;
+                    }
+
+                    TrajectoryWithFitness nextTrajectoryWithFittness = new TrajectoryWithFitness(
+                            context.getTrajectory().toArray(), nextFitness);
+                    trajectoiresToExplore.add(nextTrajectoryWithFittness);
+
+                    int compare = objectiveComparatorHelper.compare(currentTrajectoryWithFittness.fitness,
+                            nextTrajectoryWithFittness.fitness);
+                    if (compare < 0) {
+                        logger.debug("Better fitness, moving on: " + nextFitness);
+                        currentTrajectoryWithFittness = nextTrajectoryWithFittness;
+                        continue mainLoop;
+                    } else if (compare == 0) {
+                        if (onlyBetterFirst) {
+                            logger.debug("Equally good fitness, backtrack: " + nextFitness);
+                            context.backtrack();
+                            continue;
+                        } else {
+                            logger.debug("Equally good fitness, moving on: " + nextFitness);
+                            currentTrajectoryWithFittness = nextTrajectoryWithFittness;
+                            continue mainLoop;
+                        }
+                    } else {
+                        logger.debug("Worse fitness.");
+                        currentTrajectoryWithFittness = null;
+                        continue mainLoop;
+                    }
+                }
+            }
+
+            logger.debug("State is fully traversed.");
+            trajectoiresToExplore.remove(currentTrajectoryWithFittness);
+            currentTrajectoryWithFittness = null;
+
+        }
+        logger.info("Interrupted.");
+    }
+
+    @Override
+    public void interruptStrategy() {
+        isInterrupted = true;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/BreadthFirstStrategy.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/BreadthFirstStrategy.java
new file mode 100644
index 00000000..6b7d9817
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/BreadthFirstStrategy.java
@@ -0,0 +1,220 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api.strategy.impl;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.log4j.Logger;
+import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy;
+import org.eclipse.viatra.dse.base.GlobalContext;
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.Fitness;
+import org.eclipse.viatra.dse.solutionstore.SolutionStore;
+
+/**
+ * A breadth-first search algorithm implementation, that
+ * <ul>
+ * <li>can work with multiple threads,</li>
+ * <li>indeterministic,</li>
+ * <li>saves all states (trajectories) as solutions that fulfill all the hard objectives,</li>
+ * <li>can have a depth limit,</li>
+ * <li>will backtrack when a model satisfies the hard objectives (after saving it as a solution) and will not explore
+ * beyond that state.</li>
+ * </ul>
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class BreadthFirstStrategy implements IStrategy {
+
+    private static final class BfsSharedObject {
+        private final ConcurrentLinkedQueue<Object[]> trajectoryQueue1 = new ConcurrentLinkedQueue<>();
+        private final ConcurrentLinkedQueue<Object[]> trajectoryQueue2 = new ConcurrentLinkedQueue<>();
+
+        private final AtomicBoolean pushToQueue1 = new AtomicBoolean(false);
+        private final AtomicBoolean designSpaceTraversed = new AtomicBoolean(false);
+
+        public final CyclicBarrier barrier;
+
+        public BfsSharedObject(int numberOfThreads) {
+            barrier = new CyclicBarrier(numberOfThreads, () -> {
+                boolean oldValue = pushToQueue1.get();
+                pushToQueue1.set(!oldValue);
+                if (trajectoryQueue1.isEmpty() && trajectoryQueue2.isEmpty()) {
+                    designSpaceTraversed.set(true);
+                }
+            });
+        }
+
+        public Object[] poll() {
+            if (pushToQueue1.get()) {
+                return trajectoryQueue2.poll();
+            } else {
+                return trajectoryQueue1.poll();
+            }
+        }
+
+        public void push(Object[] trajectory) {
+            if (pushToQueue1.get()) {
+                trajectoryQueue1.add(trajectory);
+            } else {
+                trajectoryQueue2.add(trajectory);
+            }
+        }
+
+        public boolean isDesignSpaceTraversed() {
+            return designSpaceTraversed.get();
+        }
+    }
+
+    private int maxDepth = 0;
+    private BfsSharedObject shared;
+    private boolean isInterrupted = false;
+    private ThreadContext context;
+    private Logger logger = Logger.getLogger(IStrategy.class);
+    private SolutionStore solutionStore;
+    private boolean isFirstThread = false;
+
+    /**
+     * Creates a new breadth-first search algorithm without depth limit.
+     */
+    public BreadthFirstStrategy() {
+        this.maxDepth = Integer.MAX_VALUE;
+    }
+
+    /**
+     * Creates a new breadth-first search algorithm with depth limit.
+     * 
+     * @param maxDepth
+     *            A negative <code>maxDepth</code> means no depth limit, zero means the checking of the initial state.
+     */
+    public BreadthFirstStrategy(int maxDepth) {
+        if (maxDepth < 0) {
+            this.maxDepth = Integer.MAX_VALUE;
+        } else {
+            this.maxDepth = maxDepth;
+        }
+    }
+
+    @Override
+    public void initStrategy(ThreadContext context) {
+        this.context = context;
+        this.solutionStore = context.getGlobalContext().getSolutionStore();
+
+        GlobalContext globalContext = context.getGlobalContext();
+        if (globalContext.getSharedObject() == null) {
+            isFirstThread = true;
+            shared = new BfsSharedObject(globalContext.getThreadPool().getMaximumPoolSize());
+            globalContext.setSharedObject(shared);
+            logger.info("Breadth-first exploration strategy is inited.");
+        } else {
+            shared = (BfsSharedObject) globalContext.getSharedObject();
+        }
+    }
+
+    @Override
+    public void explore() {
+
+        if (isFirstThread) {
+
+            boolean globalConstraintsAreSatisfied = context.checkGlobalConstraints();
+            if (!globalConstraintsAreSatisfied) {
+                logger.info("Global contraint is not satisifed in the first state. Terminate.");
+                return;
+            }
+
+            Fitness fitness = context.calculateFitness();
+            if (fitness.isSatisifiesHardObjectives()) {
+                context.newSolution();
+                logger.info("First state is a solution. Terminate.");
+                return;
+            }
+
+            Object[] currentTrajectory = context.getTrajectory().toArray(new Object[0]);
+
+            shared.push(currentTrajectory);
+
+            startThreads();
+        } else {
+            try {
+                shared.barrier.await();
+            } catch (InterruptedException | BrokenBarrierException e) {
+            }
+        }
+
+        mainLoop: while (!isInterrupted && !shared.isDesignSpaceTraversed()) {
+
+            Object[] next = shared.poll();
+            while (next == null) {
+                try {
+                    logger.debug("Reached barrier.");
+                    shared.barrier.await();
+                } catch (InterruptedException | BrokenBarrierException e1) {
+                }
+                if (isInterrupted || shared.isDesignSpaceTraversed()) {
+                    break mainLoop;
+                }
+                next = shared.poll();
+            }
+
+            context.backtrackUntilRoot();
+
+            context.executeTrajectory(next);
+
+            Collection<Object> activationIds = context.getCurrentActivationIds();
+            int i = activationIds.size() - 1;
+
+            while (!isInterrupted && i >= 0) {
+
+                Iterator<Object> iterator = activationIds.iterator();
+                int index = i--;
+                while (iterator.hasNext() && index > 0) {
+                    index--;
+                    iterator.next();
+                }
+                Object activationIdToTry = iterator.next();
+
+                context.executeAcitvationId(activationIdToTry);
+
+                if (context.isCurrentStateAlreadyTraversed()) {
+                    logger.info("The new state is already visited.");
+                } else if (!context.checkGlobalConstraints()) {
+                    logger.debug("Global contraint is not satisifed.");
+                } else if (context.calculateFitness().isSatisifiesHardObjectives()) {
+                    solutionStore.newSolution(context);
+                    logger.debug("Found a solution.");
+                } else if (context.getDepth() >= maxDepth) {
+                    logger.debug("Reached max depth.");
+                } else {
+                    Object[] currentTrajectory = context.getTrajectory().toArray(new Object[0]);
+                    shared.push(currentTrajectory);
+                }
+
+                context.backtrack();
+            }
+
+        }
+    }
+
+    private void startThreads() {
+        context.startAllThreads(() -> new BreadthFirstStrategy(maxDepth));
+    }
+
+    @Override
+    public void interruptStrategy() {
+        isInterrupted = true;
+        shared.barrier.reset();
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/DepthFirstStrategy.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/DepthFirstStrategy.java
new file mode 100644
index 00000000..22a4a683
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/DepthFirstStrategy.java
@@ -0,0 +1,188 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api.strategy.impl;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.log4j.Logger;
+import org.eclipse.viatra.dse.api.DSEException;
+import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy;
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.Fitness;
+
+/**
+ * A depth-first search algorithm implementation, that
+ * <ul>
+ * <li>can work with multiple threads,</li>
+ * <li>randomly traverses the search space,</li>
+ * <li>saves all states (trajectories) as solutions that fulfill all the hard objectives,</li>
+ * <li>can have a depth limit,</li>
+ * <li>will backtrack when a model satisfies the hard objectives (after saving it as a solution), which can be modified
+ * by calling {@link #continueIfHardObjectivesFulfilled()}</li>
+ * </ul>
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class DepthFirstStrategy implements IStrategy {
+
+    private int maxDepth;
+    private AtomicBoolean isInterrupted = new AtomicBoolean(false);
+    private ThreadContext context;
+    
+    private Logger logger = Logger.getLogger(IStrategy.class);
+
+    private Random random = new Random();
+    private boolean backTrackIfSolution = true; 
+
+    /**
+     * Creates a new depth-first search algorithm without depth limit.
+     */
+    public DepthFirstStrategy() {
+        this.maxDepth = Integer.MAX_VALUE;
+    }
+
+    /**
+     * Creates a new depth-first search algorithm with depth limit.
+     * 
+     * @param maxDepth
+     *            A negative <code>maxDepth</code> means no depth limit, zero means the checking of the initial state.
+     */
+    public DepthFirstStrategy(int maxDepth) {
+        if (maxDepth < 0) {
+            this.maxDepth = Integer.MAX_VALUE;
+        } else {
+            this.maxDepth = maxDepth;
+        }
+    }
+
+    /**
+     * If called, the algorithm will not backtrack after the hard objectives are fulfilled, instead it goes deeper in
+     * the search space.
+     */
+    public DepthFirstStrategy continueIfHardObjectivesFulfilled() {
+        backTrackIfSolution = false;
+        return this;
+    }
+
+    @Override
+    public void initStrategy(ThreadContext context) {
+        this.context = context;
+
+        if (context.getSharedObject() == null) {
+            context.setSharedObject(new Object());
+            logger.info("Depth-first exploration strategy is initied.");
+            startThreads();
+        }
+        
+    }
+
+    private void startThreads() {
+        context.startAllThreads(() -> new DepthFirstStrategy(maxDepth));
+    }
+
+    @Override
+    public void explore() {
+
+        mainloop: do {
+
+            boolean globalConstraintsAreSatisfied = context.checkGlobalConstraints();
+            if (!globalConstraintsAreSatisfied) {
+                boolean isSuccessfulUndo = context.backtrack();
+                if (!isSuccessfulUndo) {
+                    logger.info("Global contraint is not satisifed and cannot backtrack.");
+                    break;
+                } else {
+                    logger.debug("Global contraint is not satisifed, backtrack.");
+                    continue;
+                }
+            }
+            
+            Fitness fitness = context.calculateFitness();
+            if (fitness.isSatisifiesHardObjectives()) {
+                context.newSolution();
+                if (backTrackIfSolution) {
+                    boolean isSuccessfulUndo = context.backtrack();
+                    if (!isSuccessfulUndo) {
+                        logger.info("Found a solution but cannot backtrack.");
+                        break;
+                    } else {
+                        logger.debug("Found a solution, backtrack.");
+                        continue;
+                    }
+                }
+            }
+
+            if (context.getDepth() >= maxDepth) {
+                boolean isSuccessfulUndo = context.backtrack();
+                if (!isSuccessfulUndo) {
+                    logger.info("Reached max depth but cannot bactrack.");
+                    break;
+                } else {
+                    logger.debug("Reached max depth, bactrack.");
+                    continue;
+                }
+            }
+            
+            if (isInterrupted.get()) {
+                logger.info("Interrupted, stop exploration.");
+                break;
+            }
+
+            Object activationId = null;
+            Collection<Object> activationIds;
+
+            do {
+                activationIds = context.getUntraversedActivationIds();
+                if (activationIds.isEmpty()) {
+                    boolean isSuccessfulUndo = context.backtrack();
+                    if (!isSuccessfulUndo) {
+                        logger.info("No more transitions from current state and cannot backtrack.");
+                        break mainloop;
+                    } else {
+                        logger.debug("No more transitions from current state, backtrack.");
+                        continue;
+                    }
+                } 
+            } while (activationIds.isEmpty());
+
+            int index = random.nextInt(activationIds.size());
+            
+            Iterator<Object> iterator = activationIds.iterator();
+            while (index-- > 0) {
+                iterator.next();
+            }
+            activationId = iterator.next();
+                
+            context.executeAcitvationId(activationId);
+
+            boolean loopInTrajectory = context.isCurrentStateInTrajectory();
+            if (loopInTrajectory) {
+                boolean isSuccessfulUndo = context.backtrack();
+                if (!isSuccessfulUndo) {
+                    throw new DSEException("The new state is present in the trajectoy but cannot bactkrack. Should never happen!");
+                } else {
+                    logger.info("The new state is already visited in the trajectory, backtrack.");
+                }
+            }
+            
+        } while (true);
+        
+        logger.info("Terminated.");
+    }
+
+    @Override
+    public void interruptStrategy() {
+        isInterrupted.set(true);
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/FixedPriorityStrategy.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/FixedPriorityStrategy.java
new file mode 100644
index 00000000..4ccda4ce
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/FixedPriorityStrategy.java
@@ -0,0 +1,208 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api.strategy.impl;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.log4j.Logger;
+import org.eclipse.viatra.dse.api.DSEException;
+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.transformation.runtime.emf.rules.batch.BatchTransformationRule;
+
+import com.google.common.collect.Lists;
+
+/**
+ * Works as {@link DepthFirstStrategy} but:
+ * <ul>
+ * <li>works only with single thread,</li>
+ * <li>in a given state, it only traverses the activations with locally the highest priority.</li>
+ * </ul>
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class FixedPriorityStrategy implements IStrategy {
+
+    private int maxDepth = Integer.MAX_VALUE;
+    private AtomicBoolean isInterrupted = new AtomicBoolean(false);
+    private ThreadContext context;
+
+    private Logger logger = Logger.getLogger(IStrategy.class);
+    private Map<BatchTransformationRule<?, ?>, Integer> priorities = new HashMap<BatchTransformationRule<?, ?>, Integer>();
+
+    private Random random = new Random();
+    private Map<Object, List<Object>> bestPriorityInState = new HashMap<>();
+
+    /**
+     * Adds a depth limit to the strategy.
+     * 
+     * @param depthLimit
+     *            The depth limit.
+     * @return The actual instance to enable a builder pattern like usage.
+     */
+    public FixedPriorityStrategy withDepthLimit(int maxDepth) {
+        if (maxDepth < 0) {
+            this.maxDepth = Integer.MAX_VALUE;
+        } else {
+            this.maxDepth = maxDepth;
+        }
+        return this;
+    }
+
+    /**
+     * Assigns a priority to a rule. Unassigned rule will have a priority of 0.
+     * 
+     * @param rule
+     *            The transformation rule.
+     * @param priority
+     *            The priority of the rule. Higher is better.
+     * @return The actual instance to enable a builder pattern like usage.
+     */
+    public FixedPriorityStrategy withRulePriority(BatchTransformationRule<?, ?> rule, int priority) {
+        priorities.put(rule, priority);
+        return this;
+    }
+
+    public Map<BatchTransformationRule<?, ?>, Integer> getPriorities() {
+        return priorities;
+    }
+
+    @Override
+    public void initStrategy(ThreadContext context) {
+        this.context = context;
+
+        logger.info("Fixed priority exploration strategy is initied.");
+    }
+
+    @Override
+    public void explore() {
+
+        mainloop: do {
+
+            boolean globalConstraintsAreSatisfied = context.checkGlobalConstraints();
+            if (!globalConstraintsAreSatisfied) {
+                boolean isSuccessfulUndo = context.backtrack();
+                if (!isSuccessfulUndo) {
+                    logger.info("Global contraint is not satisifed and cannot backtrack.");
+                    break;
+                } else {
+                    logger.debug("Global contraint is not satisifed, backtrack.");
+                    continue;
+                }
+            }
+
+            Fitness fitness = context.calculateFitness();
+            if (fitness.isSatisifiesHardObjectives()) {
+                context.newSolution();
+                boolean isSuccessfulUndo = context.backtrack();
+                if (!isSuccessfulUndo) {
+                    logger.info("Found a solution but cannot backtrack.");
+                    break;
+                } else {
+                    logger.debug("Found a solution, backtrack.");
+                    continue;
+                }
+            }
+
+            if (context.getDepth() >= maxDepth) {
+                boolean isSuccessfulUndo = context.backtrack();
+                if (!isSuccessfulUndo) {
+                    logger.info("Reached max depth but cannot bactrack.");
+                    break;
+                } else {
+                    logger.debug("Reached max depth, bactrack.");
+                    continue;
+                }
+            }
+
+            if (isInterrupted.get()) {
+                logger.info("Interrupted, stop exploration.");
+                break;
+            }
+
+            List<Object> transitions;
+
+            do {
+
+                transitions = bestPriorityInState.get(context.getCurrentStateId());
+
+                if (transitions == null) {
+                    Integer bestPriority = getBestPriority(context.getCurrentActivationIds());
+                    transitions = Lists.newArrayList();
+                    for (Object iTransition : context.getCurrentActivationIds()) {
+                        Integer integer = priorities.get(context.getRuleByActivationId(iTransition));
+                        if (integer == null) {
+                            integer = Integer.valueOf(0);
+                        }
+                        if (integer.equals(bestPriority)) {
+                            transitions.add(iTransition);
+                        }
+                    }
+                    bestPriorityInState.put(context.getCurrentStateId(), transitions);
+                }
+
+                if (transitions.isEmpty()) {
+                    boolean isSuccessfulUndo = context.backtrack();
+                    if (!isSuccessfulUndo) {
+                        logger.info("No more transitions from current state and cannot backtrack.");
+                        break mainloop;
+                    } else {
+                        logger.debug("No more transitions from current state, backtrack.");
+                        continue;
+                    }
+                }
+            } while (transitions.isEmpty());
+
+            int index = random.nextInt(transitions.size());
+            Object transition = transitions.remove(index);
+
+            context.executeAcitvationId(transition);
+
+            boolean loopInTrajectory = context.isCurrentStateInTrajectory();
+            if (loopInTrajectory) {
+                boolean isSuccessfulUndo = context.backtrack();
+                if (!isSuccessfulUndo) {
+                    throw new DSEException(
+                            "The new state is present in the trajectoy but cannot bactkrack. Should never happen!");
+                } else {
+                    logger.info("The new state is already visited in the trajectory, backtrack.");
+                }
+            }
+
+        } while (true);
+
+        logger.info("Terminated.");
+    }
+
+    @Override
+    public void interruptStrategy() {
+        isInterrupted.set(true);
+    }
+
+    private Integer getBestPriority(Collection<? extends Object> transitions) {
+        Integer bestPriority = Integer.MIN_VALUE;
+        for (Object iTransition : transitions) {
+            Integer priority = priorities.get(context.getRuleByActivationId(iTransition));
+            if (priority == null) {
+                priority = Integer.valueOf(0);
+            }
+            if (priority > bestPriority) {
+                bestPriority = priority;
+            }
+        }
+        return bestPriority;
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/HillClimbingStrategy.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/HillClimbingStrategy.java
new file mode 100644
index 00000000..0ccb0668
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/HillClimbingStrategy.java
@@ -0,0 +1,142 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api.strategy.impl;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.log4j.Logger;
+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.objectives.TrajectoryFitness;
+
+public class HillClimbingStrategy implements IStrategy {
+
+    private AtomicBoolean isInterrupted = new AtomicBoolean(false);
+    private ThreadContext context;
+
+    private Logger logger = Logger.getLogger(IStrategy.class);
+
+    private Random random = new Random();
+    private double percentOfOpenedStates;
+    private ObjectiveComparatorHelper objectiveComparatorHelper;
+
+    public HillClimbingStrategy() {
+        this(2);
+    }
+
+    public HillClimbingStrategy(double percentOfOpenedStates) {
+        this.percentOfOpenedStates = percentOfOpenedStates;
+    }
+
+    @Override
+    public void initStrategy(ThreadContext context) {
+        this.context = context;
+        objectiveComparatorHelper = context.getObjectiveComparatorHelper();
+        logger.info("Hill climbing exploration strategy is initied.");
+    }
+
+    @Override
+    public void explore() {
+
+        boolean globalConstraintsAreSatisfied = context.checkGlobalConstraints();
+        if (!globalConstraintsAreSatisfied) {
+            boolean isSuccessfulUndo = context.backtrack();
+            if (!isSuccessfulUndo) {
+                logger.info("Global contraint is not satisifed and cannot backtrack.");
+                return;
+            }
+        }
+
+        mainloop: do {
+
+            Fitness previousFitness = context.calculateFitness();
+
+            logger.debug("Current depth: " + context.getDepth() + " Fitness: " + previousFitness);
+
+            Collection<Object> transitionsFromCurrentState = context.getCurrentActivationIds();
+
+            while (transitionsFromCurrentState.isEmpty()) {
+                logger.debug("No transitions from current state: considered as a solution.");
+                saveSolutionAndBacktrack();
+                continue mainloop;
+            }
+
+            ArrayList<Object> transitionsToTry = new ArrayList<>(transitionsFromCurrentState.size());
+            for (Object transition : transitionsFromCurrentState) {
+                transitionsToTry.add(transition);
+            }
+            double numberOfTransitionsToTry = transitionsToTry.size() * percentOfOpenedStates;
+
+            for (; numberOfTransitionsToTry > 0 && !transitionsToTry.isEmpty(); numberOfTransitionsToTry--) {
+                int index = random.nextInt(transitionsToTry.size());
+                Object transition = transitionsToTry.remove(index);
+
+                context.executeAcitvationId(transition);
+
+                if (!context.checkGlobalConstraints()) {
+                    logger.debug("Global contraint is not satisifed, backtrack.");
+                    context.backtrack();
+                    continue;
+                }
+                if (context.isCurrentStateInTrajectory()) {
+                    logger.debug("Current state is in trajectory, backtrack.");
+                    context.backtrack();
+                    continue;
+                }
+
+                Fitness fitness = context.calculateFitness();
+                objectiveComparatorHelper.addTrajectoryFitness(
+                        new TrajectoryFitness(context.getTrajectoryInfo().getLastActivationId(), fitness));
+                context.backtrack();
+            }
+
+            if (objectiveComparatorHelper.getTrajectoryFitnesses().isEmpty()) {
+                logger.debug("No viable transitions from current state: considered as a solution.");
+                saveSolutionAndBacktrack();
+                continue;
+            }
+
+            TrajectoryFitness randomBestFitness = objectiveComparatorHelper.getRandomBest();
+            objectiveComparatorHelper.clearTrajectoryFitnesses();
+
+            int compare = objectiveComparatorHelper.compare(previousFitness, randomBestFitness.fitness);
+
+            if (compare > 0) {
+                saveSolutionAndBacktrack();
+                continue;
+            } else {
+                previousFitness = randomBestFitness.fitness;
+                Object transition = randomBestFitness.trajectory[randomBestFitness.trajectory.length - 1];
+                context.executeAcitvationId(transition);
+            }
+
+        } while (!isInterrupted.get());
+
+        logger.info("Terminated.");
+    }
+
+    private void saveSolutionAndBacktrack() {
+        context.calculateFitness();
+        context.newSolution();
+        logger.debug("Found solution: " + context.getTrajectoryInfo().toString());
+        logger.debug("Backtrack for more solutions, if needed.");
+        context.backtrackUntilRoot();
+    }
+
+    @Override
+    public void interruptStrategy() {
+        isInterrupted.set(true);
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/RandomSearchStrategy.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/RandomSearchStrategy.java
new file mode 100644
index 00000000..af8fb8cc
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/impl/RandomSearchStrategy.java
@@ -0,0 +1,163 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api.strategy.impl;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.log4j.Logger;
+import org.eclipse.viatra.dse.api.DSEException;
+import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy;
+import org.eclipse.viatra.dse.base.GlobalContext;
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.designspace.api.TrajectoryInfo;
+import org.eclipse.viatra.dse.objectives.Fitness;
+
+public class RandomSearchStrategy implements IStrategy {
+
+    private static class SharedData {
+        public final AtomicInteger triesLeft;
+        public final int minDepth;
+        public final int maxDepth;
+
+        public SharedData(int minDepth, int maxDepth, int numberOfTries) {
+            this.minDepth = minDepth;
+            this.maxDepth = maxDepth;
+            this.triesLeft = new AtomicInteger(numberOfTries);
+        }
+    }
+
+    private int maxDepth = -1;
+    private Random rnd = new Random();
+    private SharedData shared;
+    private TrajectoryInfo trajectoryInfo;
+    int nth;
+    private ThreadContext context;
+    private AtomicBoolean isInterrupted = new AtomicBoolean(false);
+    private Logger logger = Logger.getLogger(IStrategy.class);
+
+    public RandomSearchStrategy(int minDepth, int maxDepth, int numberOfTries) {
+        shared = new SharedData(minDepth, maxDepth, numberOfTries);
+    }
+
+    private RandomSearchStrategy() {
+    }
+
+    @Override
+    public void initStrategy(ThreadContext context) {
+        this.context = context;
+        trajectoryInfo = context.getTrajectoryInfo();
+        GlobalContext gc = context.getGlobalContext();
+
+        Object sharedObject = gc.getSharedObject();
+        if (sharedObject == null) {
+            gc.setSharedObject(shared);
+            logger.info("Random exploration strategy is initied.");
+            startThreads();
+        } else {
+            shared = (SharedData) sharedObject;
+        }
+
+        maxDepth = rnd.nextInt(shared.maxDepth - shared.minDepth) + shared.minDepth;
+
+    }
+
+    @Override
+    public void explore() {
+
+        do {
+
+            boolean globalConstraintsAreSatisfied = context.checkGlobalConstraints();
+            if (!globalConstraintsAreSatisfied) {
+                boolean isSuccessfulUndo = context.backtrack();
+                if (!isSuccessfulUndo) {
+                    logger.info("Global contraint is not satisifed and cannot backtrack.");
+                    break;
+                } else {
+                    logger.debug("Global contraint is not satisifed, backtrack.");
+                    continue;
+                }
+            }
+
+            Fitness fitness = context.calculateFitness();
+            if (fitness.isSatisifiesHardObjectives()) {
+                context.newSolution();
+                boolean isSuccessfulUndo = context.backtrack();
+                if (!isSuccessfulUndo) {
+                    logger.info("Found a solution but cannot backtrack.");
+                    break;
+                } else {
+                    logger.debug("Found a solution, backtrack.");
+                    continue;
+                }
+            }
+
+            if (trajectoryInfo.getDepth() < maxDepth) {
+
+                Collection<Object> transitions = context.getCurrentActivationIds();
+                int index = rnd.nextInt(transitions.size());
+                Object transition = getByIndex(transitions, index);
+                context.executeAcitvationId(transition);
+
+            } else {
+
+                nth = shared.triesLeft.getAndDecrement();
+                logger.debug(nth + " tries left");
+                if (nth > 0) {
+
+                    context.backtrackUntilRoot();
+                    maxDepth = rnd.nextInt(shared.maxDepth - shared.minDepth) + shared.minDepth;
+
+                } else {
+                    break;
+                }
+            }
+
+            boolean loopInTrajectory = context.isCurrentStateInTrajectory();
+            if (loopInTrajectory) {
+                boolean isSuccessfulUndo = context.backtrack();
+                if (!isSuccessfulUndo) {
+                    throw new DSEException(
+                            "The new state is present in the trajectoy but cannot bactkrack. Should never happen!");
+                } else {
+                    logger.info("The new state is already visited in the trajectory, backtrack.");
+                }
+            }
+
+        } while (isInterrupted.get());
+
+        logger.info("Terminated.");
+    }
+
+    @Override
+    public void interruptStrategy() {
+        isInterrupted.set(true);
+    }
+
+    private void startThreads() {
+        context.startAllThreads(RandomSearchStrategy::new);
+    }
+
+    private static Object getByIndex(Collection<Object> availableTransitions, int index) {
+        int i = 0;
+        Iterator<Object> iterator = availableTransitions.iterator();
+        while (iterator.hasNext()) {
+            Object transition = iterator.next();
+            if (i == index) {
+                return transition;
+            } else {
+                ++i;
+            }
+        }
+        throw new IndexOutOfBoundsException("size: " + availableTransitions.size() + ", index: " + index);
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/interfaces/IStrategy.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/interfaces/IStrategy.java
new file mode 100644
index 00000000..8c164396
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/interfaces/IStrategy.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api.strategy.interfaces;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.solutionstore.SolutionStore;
+
+/**
+ * This high level interface is responsible for defining basic operations of an exploration strategy.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public interface IStrategy {
+
+    /**
+     * Initializes the strategy with a specific {@link ThreadContext}.
+     * 
+     * @param context
+     *            The context.
+     */
+    void initStrategy(ThreadContext context);
+
+    /**
+     * This method explores the design space as the implementation specifies. It will be called only once, hence the
+     * exploration loop is run by the implementation. The termination condition is also specified by the implementation
+     * and when it returns the exploration thread will be disposed.
+     */
+    void explore();
+
+    /**
+     * The implementation of this interface should be ready to be interrupted. If this method is called, the
+     * {@link IStrategy#explore()} method should return ASAP.
+     * 
+     * This method is also called by the {@link SolutionStore} class if enough solutions are found. 
+     */
+    void interruptStrategy();
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/interfaces/IStrategyFactory.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/interfaces/IStrategyFactory.java
new file mode 100644
index 00000000..b3352d13
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/api/strategy/interfaces/IStrategyFactory.java
@@ -0,0 +1,13 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.api.strategy.interfaces;
+
+public interface IStrategyFactory {
+    IStrategy createStrategy();
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/ActivationCodesConflictSet.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/ActivationCodesConflictSet.java
new file mode 100644
index 00000000..d3990c23
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/ActivationCodesConflictSet.java
@@ -0,0 +1,213 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.base;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import org.eclipse.viatra.dse.statecode.IStateCoder;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.transformation.evm.api.Activation;
+import org.eclipse.viatra.transformation.evm.api.resolver.ChangeableConflictSet;
+import org.eclipse.viatra.transformation.evm.api.resolver.ConflictResolver;
+import org.eclipse.viatra.transformation.evm.api.resolver.ConflictSet;
+
+public class ActivationCodesConflictSet implements ChangeableConflictSet {
+
+    private static class ActivationCodesMultiBiMap {
+        public Map<Activation<?>, Object> activationsToCodes = new HashMap<>();
+        public Map<Object, Set<Activation<?>>> codesToActivations = new HashMap<>();
+
+        public void addActivation(Activation<?> activation, Object activationCode) {
+            activationsToCodes.put(activation, activationCode);
+            codesToActivations.computeIfAbsent(activationCode, k -> new HashSet<>()).add(activation);
+        }
+
+        public void removeActivaion(Activation<?> activation) {
+            Object activationCode = activationsToCodes.remove(activation);
+            Set<Activation<?>> activations = codesToActivations.get(activationCode);
+            if (activations != null) {
+                activations.remove(activation);
+            }
+        }
+
+        public void clear() {
+            activationsToCodes.clear();
+            codesToActivations.clear();
+        }
+    }
+    
+    protected ActivationCodesMultiBiMap activationCodes;
+    protected IStateCoder stateCoder;
+
+    protected Set<Activation<?>> newActivations = new HashSet<>();
+    protected Set<Activation<?>> removedActivations = new HashSet<>();
+//    private Logger logger = Logger.getLogger(getClass());
+
+    private boolean isIncremental = false;
+    private ConflictSet nextActivationsConflictSet;
+
+    public void setIncremental(boolean isIncremental) {
+        this.isIncremental = isIncremental;
+    }
+
+    public ActivationCodesConflictSet(ConflictSet nextActivationsConflictSet, IStateCoder stateCoder) {
+        Objects.requireNonNull(nextActivationsConflictSet);
+        this.nextActivationsConflictSet = nextActivationsConflictSet;
+        this.stateCoder = stateCoder;
+        activationCodes = new ActivationCodesMultiBiMap();
+    }
+
+    private Object createActivationCode(Activation<?> activation) {
+        return stateCoder.createActivationCode((IPatternMatch) activation.getAtom());
+    }
+
+    @Override
+    public boolean removeActivation(Activation<?> activation) {
+        if (isIncremental) {
+//*
+            removedActivations.add(activation);
+            newActivations.remove(activation);
+/*/
+            if(!removedActivations.add(activation)) {
+                logger.debug("Abnormal: already marked to remove: " + activation);
+            } else {
+                logger.debug("marked to remove: " + activation);
+            }
+            if(newActivations.remove(activation)) {
+                logger.debug("Abnormal: removed from new activations: " + activation);
+            }
+//*/
+        }
+        return false;
+    }
+
+    @Override
+    public boolean addActivation(Activation<?> activation) {
+        if (isIncremental) {
+//*
+            newActivations.add(activation);
+            removedActivations.remove(activation);
+            /*/
+            if (activation.isEnabled()) {
+                if (!newActivations.add(activation)) {
+                    logger.debug("Abnormal: already added as new: " + activation);
+                } else {
+                    logger.debug("activation added: " + activation);
+                }
+            }
+            if(removedActivations.remove(activation)) {
+                logger.debug("Abnormal: was already marked to remove: " + activation);
+            }
+//*/
+        }
+        return false;
+    }
+
+    public Object getActivationId(Activation<?> activation) {
+        return activationCodes.activationsToCodes.get(activation);
+    }
+
+    public Activation<?> getActivation(Object activationId) {
+        Set<Activation<?>> activationsSet = activationCodes.codesToActivations.get(activationId);
+        if (activationsSet == null || activationsSet.isEmpty()) {
+            return null;
+        } else {
+            return activationsSet.iterator().next();
+        }
+    }
+
+    public void updateActivationCodes() {
+//        logger.debug("Updating activation codes.");
+
+        if (isIncremental) {
+          for (Activation<?> activation : removedActivations) {
+              activationCodes.removeActivaion(activation);
+//              logger.debug("removed activation: " + activationId);
+          }
+    
+          for (Activation<?> activation : newActivations) {
+              if (activation.getState().isInactive()) {
+                  continue;
+              }
+              Object activationCode = createActivationCode(activation);
+              activationCodes.addActivation(activation, activationCode);
+//              logger.debug("new activation: " + activationId);
+//              Activation<?> similarActivation = activationIds.inverse().get(activationId);
+//              if (similarActivation != null) {
+//                  logger.debug("Activation " + toStringAct(activation) + " is already present with id: " + activationId);
+//                  if (similarActivation.isEnabled()) {
+//                      logger.warn("Duplicate activation code: " + activationId);
+//                  } else {
+//                      logger.debug("Force put: " + activationId);
+//                  }
+//                  continue;
+//              }
+//              activationIds.put(activation, activationId);
+          }
+          removedActivations.clear();
+          newActivations.clear();
+        } else {
+            activationCodes.clear();
+            for (Activation<?> activation : nextActivationsConflictSet.getNextActivations()) {
+                Object activationCode = createActivationCode(activation);
+                activationCodes.addActivation(activation, activationCode);
+            }
+        }
+
+
+    }
+
+    protected void reinitWithActivations(ConflictSet nextActivationsConflictSet) {
+        this.nextActivationsConflictSet = nextActivationsConflictSet;
+        activationCodes.clear();
+        for (Activation<?> activation : nextActivationsConflictSet.getNextActivations()) {
+            Object activationCode = createActivationCode(activation);
+            activationCodes.addActivation(activation, activationCode);
+        }
+    }
+
+    @Override
+    public Activation<?> getNextActivation() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Set<Activation<?>> getNextActivations() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Set<Activation<?>> getConflictingActivations() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public ConflictResolver getConflictResolver() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        for (Object activationCode : activationCodes.activationsToCodes.values()) {
+            sb.append(activationCode);
+            sb.append(" | ");
+        }
+        return sb.toString();
+    }
+
+    public Collection<Object> getCurrentActivationCodes() {
+        return activationCodes.activationsToCodes.values();
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DesignSpaceManager.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DesignSpaceManager.java
new file mode 100644
index 00000000..133ef948
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DesignSpaceManager.java
@@ -0,0 +1,577 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.base;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.edit.command.ChangeCommand;
+import org.eclipse.emf.edit.domain.EditingDomain;
+import org.eclipse.viatra.dse.api.DSEException;
+import org.eclipse.viatra.dse.api.SolutionTrajectory;
+import org.eclipse.viatra.dse.designspace.api.IBacktrackListener;
+import org.eclipse.viatra.dse.designspace.api.IDesignSpace;
+import org.eclipse.viatra.dse.designspace.api.TrajectoryInfo;
+import org.eclipse.viatra.dse.objectives.ActivationFitnessProcessor;
+import org.eclipse.viatra.dse.statecode.IStateCoder;
+import org.eclipse.viatra.dse.visualizer.IExploreEventHandler;
+import org.eclipse.viatra.query.runtime.api.AdvancedViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.transformation.evm.api.Activation;
+import org.eclipse.viatra.transformation.evm.api.Context;
+import org.eclipse.viatra.transformation.evm.api.resolver.ChangeableConflictSet;
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule;
+
+public class DesignSpaceManager implements IBacktrackListener {
+
+        private final IStateCoder stateCoder;
+        private final EditingDomain domain;
+        private Notifier model;
+
+        private IDesignSpace designSpace;
+
+        private final TrajectoryInfo trajectory;
+
+        // the occurence vector callback
+        private List<IExploreEventHandler> handlers;
+
+        // Dummy context for evm
+        private final Context evmContext = Context.create();
+
+        private Logger logger = Logger.getLogger(this.getClass());
+
+        private boolean isNewState = false;
+        private Map<BatchTransformationRule<?, ?>, ActivationFitnessProcessor> activationFitnessProcessors;
+        private Map<BatchTransformationRule<?, ?>, String> activationFitnessProcessorNames;
+        private ThreadContext context;
+
+        private ActivationCodesConflictSet activationCodes;
+        private ChangeableConflictSet conflictSet;
+
+        private AdvancedViatraQueryEngine engine;
+
+        private Random random = new Random();
+
+        private long forwardTime = 0;
+        private long backtrackingTime = 0;
+
+        public DesignSpaceManager(ThreadContext context) {
+
+                this.context = context;
+                model = context.getModel();
+                designSpace = context.getGlobalContext().getDesignSpace();
+                domain = context.getEditingDomain();
+
+                conflictSet = context.getConflictResolver().getLastCreatedConflictSet();
+
+                stateCoder = context.getStateCoder();
+                Object initialStateId = stateCoder.createStateCode();
+                designSpace.addState(null, null, initialStateId);
+
+                activationCodes = context.getActivationCodesConflictSet();
+
+                engine = (AdvancedViatraQueryEngine) context.getQueryEngine();
+
+                this.trajectory = new TrajectoryInfo(initialStateId);
+
+                logger.debug("DesignSpaceManager initialized with initial model: " + initialStateId);
+        }
+
+        public void fireActivation(final Object transition) {
+                if (fireActivationSilent(transition)) {
+                        return;
+                }
+
+                StringBuilder sb = new StringBuilder();
+                sb.append(
+                                "A retrieved Transition SHOULD have a matching Activation. Possible causes: the state serializer is faulty; the algorithm choosed a wrong Transition.");
+                sb.append("\nSought transition: ");
+                sb.append(transition);
+                Object currentStateId = getCurrentState();
+                sb.append("\nCurrent known state: ");
+                sb.append(currentStateId);
+                Object actualStateId = stateCoder.createStateCode();
+                sb.append("\nActual state: ");
+                sb.append((actualStateId.equals(currentStateId) ? "same as current" : actualStateId));
+                sb.append("\n");
+                sb.append(trajectory);
+                sb.append("\nAvailable transitions:");
+                for (Activation<?> act : conflictSet.getNextActivations()) {
+                        IPatternMatch match = (IPatternMatch) act.getAtom();
+                        Object code = generateMatchCode(match);
+                        sb.append("\n\t");
+                        sb.append(code);
+                }
+
+                throw new DSEException(sb.toString());
+        }
+
+        public boolean tryFireActivation(final Object transition) {
+                return fireActivationSilent(transition);
+        }
+
+        private boolean fireActivationSilent(final Object transition) {
+                final Activation<?> activation = getActivationById(transition);
+
+                if (activation == null) {
+                        return false;
+                }
+
+                BatchTransformationRule<?, ?> rule = getRuleByActivation(activation);
+
+                Map<String, Double> measureCosts = new HashMap<String, Double>();
+                if (activationFitnessProcessors != null && activationFitnessProcessors.containsKey(rule)) {
+                        IPatternMatch match = (IPatternMatch) activation.getAtom();
+                        ActivationFitnessProcessor processor = activationFitnessProcessors.get(rule);
+                        double fitness = processor.process(match);
+                        measureCosts.put(activationFitnessProcessorNames.get(rule), fitness);
+                }
+
+                ChangeCommand rc = new ChangeCommand(model) {
+                        @Override
+                        protected void doExecute() {
+                                activation.fire(evmContext);
+                        }
+                };
+
+                Object previousState = trajectory.getCurrentStateId();
+
+                long start = System.nanoTime();
+                try {
+                        engine.delayUpdatePropagation(() -> {
+                                domain.getCommandStack().execute(rc);
+                                return null;
+                        });
+                } catch (InvocationTargetException e) {
+                        throw new RuntimeException(e);
+                }
+                forwardTime += System.nanoTime() - start;
+
+                Object newStateId = stateCoder.createStateCode();
+                updateActivationCodes();
+
+                if (designSpace != null) {
+                        isNewState = !designSpace.isTraversed(newStateId);
+                        designSpace.addState(previousState, transition, newStateId);
+                }
+
+                trajectory.addStep(transition, rule, newStateId, measureCosts);
+
+                if (handlers != null) {
+                        for (IExploreEventHandler iExploreEventHandler : handlers) {
+                                iExploreEventHandler.transitionFired(transition);
+                        }
+                }
+
+                logger.debug("Executed activation: " + transition);/*
+                                                                                                                         * + " from state: " + previousState + " to " + newStateId);
+                                                                                                                         */
+
+                return true;
+        }
+
+        public boolean executeRandomActivationId() {
+                Collection<Object> transitions = getTransitionsFromCurrentState();
+                int size = transitions.size();
+                if (size == 0) {
+                        return false;
+                }
+
+                int index = random.nextInt(size);
+                Iterator<Object> iterator = transitions.iterator();
+                for (int i = 0; i < index; ++i) {
+                        iterator.next();
+                }
+                Object transition = iterator.next();
+
+                fireActivation(transition);
+                return true;
+        }
+
+        public int executeTrajectory(Object[] trajectoryToExecute) {
+                return executeTrajectory(trajectoryToExecute, 0, trajectoryToExecute.length, false, true);
+        }
+
+        public int executeTrajectory(Object[] trajectoryToExecute, int fromIncludedIndex, int toExcludedIndex) {
+                return executeTrajectory(trajectoryToExecute, fromIncludedIndex, toExcludedIndex, false, true);
+        }
+
+        public int executeTrajectoryByTrying(Object[] trajectoryToExecute) {
+                return executeTrajectory(trajectoryToExecute, 0, trajectoryToExecute.length, true, true);
+        }
+
+        public int executeTrajectoryByTrying(Object[] trajectoryToExecute, int fromIncludedIndex, int toExcludedIndex) {
+                return executeTrajectory(trajectoryToExecute, fromIncludedIndex, toExcludedIndex, true, true);
+        }
+
+        public int executeTrajectoryWithoutStateCoding(Object[] trajectoryToExecute) {
+                return executeTrajectory(trajectoryToExecute, 0, trajectoryToExecute.length, false, false);
+        }
+
+        public int executeTrajectoryWithoutStateCoding(Object[] trajectoryToExecute, int fromIncludedIndex,
+                        int toExcludedIndex) {
+                return executeTrajectory(trajectoryToExecute, fromIncludedIndex, toExcludedIndex, false, false);
+        }
+
+        public int executeTrajectoryByTryingWithoutStateCoding(Object[] trajectoryToExecute) {
+                return executeTrajectory(trajectoryToExecute, 0, trajectoryToExecute.length, true, false);
+        }
+
+        public int executeTrajectoryByTryingWithoutStateCoding(Object[] trajectoryToExecute, int fromIncludedIndex,
+                        int toExcludedIndex) {
+                return executeTrajectory(trajectoryToExecute, fromIncludedIndex, toExcludedIndex, true, false);
+        }
+
+        private int executeTrajectory(Object[] trajectoryToExecute, int fromIncludedIndex, int toExcludedIndex,
+                        boolean tryAllActivations, boolean createStateCode) {
+                logger.debug("Executing trajectory.");
+                int unsuccesfulIndex = -1;
+                if (tryAllActivations) {
+                        unsuccesfulIndex = 0;
+                }
+                for (int i = fromIncludedIndex; i < toExcludedIndex; i++) {
+                        Object activationId = trajectoryToExecute[i];
+                        final Activation<?> activation = getActivationById(activationId);
+
+                        if (activation == null) {
+                                logger.debug("Couldn't execute activation: " + activationId);
+                                if (tryAllActivations) {
+                                        unsuccesfulIndex++;
+                                        continue;
+                                } else {
+                                        unsuccesfulIndex = i;
+                                        logger.debug("Trajectory execution stopped at index " + i + "/" + trajectoryToExecute.length);
+                                        break;
+                                }
+                        }
+
+                        BatchTransformationRule<?, ?> rule = getRuleByActivation(activation);
+
+                        Map<String, Double> measureCosts = new HashMap<String, Double>();
+                        if (activationFitnessProcessors != null && activationFitnessProcessors.containsKey(rule)) {
+                                IPatternMatch match = (IPatternMatch) activation.getAtom();
+                                ActivationFitnessProcessor processor = activationFitnessProcessors.get(rule);
+                                double fitness = processor.process(match);
+                                measureCosts.put(activationFitnessProcessorNames.get(rule), fitness);
+                        }
+
+                        ChangeCommand rc = new ChangeCommand(model) {
+                                @Override
+                                protected void doExecute() {
+                                        activation.fire(evmContext);
+                                }
+                        };
+                        
+                        long start = System.nanoTime();
+                        try {
+                                engine.delayUpdatePropagation(() -> {
+                                        domain.getCommandStack().execute(rc);
+                                        return null;
+                                });
+                        } catch (InvocationTargetException e) {
+                                throw new RuntimeException(e);
+                        }
+                        forwardTime += System.nanoTime() - start;
+
+                        Object newStateId = null;
+                        if (createStateCode) {
+                                newStateId = stateCoder.createStateCode();
+                        }
+                        updateActivationCodes();
+
+                        trajectory.addStep(activationId, rule, newStateId, measureCosts);
+
+                        logger.debug("Activation executed: " + activationId);
+                }
+                if (!createStateCode) {
+                        trajectory.modifyLastStateCode(stateCoder.createStateCode());
+                }
+                logger.debug("Trajectory execution finished.");
+                return unsuccesfulIndex;
+
+        }
+
+        public Object getTransitionByActivation(Activation<?> activation) {
+                return activationCodes.getActivationId(activation);
+        }
+
+        public Activation<?> getActivationById(Object activationId) {
+                return activationCodes.getActivation(activationId);
+        }
+
+        public BatchTransformationRule<?, ?> getRuleByActivation(Activation<?> activation) {
+                return context.getGlobalContext().getSpecificationRuleMap().get(activation.getInstance().getSpecification());
+        }
+
+        public BatchTransformationRule<?, ?> getRuleByActivationId(Object activationId) {
+                return getRuleByActivation(getActivationById(activationId));
+        }
+
+        /**
+         * Returns true if the given state is not owned by this crawler.
+         * 
+         **/
+        public boolean isNewModelStateAlreadyTraversed() {
+                return !isNewState;
+        }
+
+        public List<Object> getTrajectoryFromRoot() {
+                return trajectory.getTrajectory();
+        }
+
+        public Collection<Object> getTransitionsFromCurrentState() {
+                return activationCodes.getCurrentActivationCodes();
+        }
+
+        public Collection<Object> getUntraversedTransitionsFromCurrentState() {
+                if (designSpace == null) {
+                        throw new DSEException("Unsupported without a design space");
+                }
+                Object currentState = trajectory.getCurrentStateId();
+                Collection<Object> traversedIds = designSpace.getActivationIds(currentState);
+
+                List<Object> untraversedTransitions = new ArrayList<>();
+                for (Object activationId : activationCodes.getCurrentActivationCodes()) {
+                        if (!traversedIds.contains(activationId)) {
+                                untraversedTransitions.add(activationId);
+                        }
+                }
+
+                return untraversedTransitions;
+        }
+
+        public boolean undoLastTransformation() {
+
+                if (!trajectory.canStepBack()) {
+                        return false;
+                }
+
+                long start = System.nanoTime();
+                try {
+                        engine.delayUpdatePropagation(() -> {
+                                domain.getCommandStack().undo();
+                                return null;
+                        });
+                } catch (InvocationTargetException e) {
+                        throw new RuntimeException(e);
+                }
+                backtrackingTime += System.nanoTime() - start;
+                updateActivationCodes();
+
+                Object lastActivationId = trajectory.getLastActivationId();
+
+                trajectory.backtrack();
+
+                if (handlers != null) {
+                        for (IExploreEventHandler iExploreEventHandler : handlers) {
+                                iExploreEventHandler.undo(lastActivationId);
+                        }
+                }
+
+                logger.debug("Backtrack.");
+
+                return true;
+        }
+
+        public void backtrackXTimes(int steps) {
+                long start = System.nanoTime();
+                try {
+                        engine.delayUpdatePropagation(() -> {
+                                for (int i = steps; i > 0; i--) {
+                                        domain.getCommandStack().undo();
+                                        trajectory.backtrack();
+                                }
+                                return null;
+                        });
+                } catch (InvocationTargetException e) {
+                        throw new RuntimeException(e);
+                }
+                backtrackingTime += System.nanoTime() - start;
+                updateActivationCodes();
+                logger.debug("Backtracked " + steps + " times.");
+        }
+
+        public int backtrackUntilLastCommonActivation(Object[] newTrajectory) {
+                long start = System.nanoTime();
+                Iterator<Object> currentTrajectoryIterator = trajectory.getTrajectory().iterator();
+                if (!currentTrajectoryIterator.hasNext()) {
+                        return 0;
+                }
+                int indexOfLastCommonActivation = 0;
+                for (Object activationCode : newTrajectory) {
+                        if (currentTrajectoryIterator.hasNext()) {
+                                Object activationCodeFromCurrent = currentTrajectoryIterator.next();
+                                if (activationCodeFromCurrent.equals(activationCode)) {
+                                        indexOfLastCommonActivation++;
+                                } else {
+                                        break;
+                                }
+                        } else {
+                                // current trajectory is smaller
+                                break;
+                        }
+                }
+                int numberOfBacktracks = trajectory.getDepth() - indexOfLastCommonActivation;
+                if (numberOfBacktracks > 0) {
+                        try {
+                                engine.delayUpdatePropagation(() -> {
+                                        for (int i = numberOfBacktracks; i > 0; i--) {
+                                                domain.getCommandStack().undo();
+                                                trajectory.backtrack();
+                                        }
+                                        return null;
+                                });
+                        } catch (InvocationTargetException e) {
+                                throw new RuntimeException(e);
+                        }
+                }
+                backtrackingTime += System.nanoTime() - start;
+                updateActivationCodes();
+                logger.debug("Backtracked " + numberOfBacktracks + " times.");
+                return indexOfLastCommonActivation;
+        }
+
+        public void executeTrajectoryWithMinimalBacktrack(Object[] trajectory) {
+                executeTrajectoryWithMinimalBacktrack(trajectory, trajectory.length);
+        }
+
+        public void executeTrajectoryWithMinimalBacktrack(Object[] trajectory, int toExcludedIndex) {
+                int fromIndex = backtrackUntilLastCommonActivation(trajectory);
+                executeTrajectory(trajectory, fromIndex, toExcludedIndex, false, true);
+        }
+
+        public void executeTrajectoryWithMinimalBacktrackWithoutStateCoding(Object[] trajectory) {
+                executeTrajectoryWithMinimalBacktrackWithoutStateCoding(trajectory, trajectory.length);
+        }
+
+        public void executeTrajectoryWithMinimalBacktrackWithoutStateCoding(Object[] trajectory, int toExcludedIndex) {
+                int fromIndex = backtrackUntilLastCommonActivation(trajectory);
+                executeTrajectory(trajectory, fromIndex, toExcludedIndex, false, false);
+                Object stateCode = stateCoder.createStateCode();
+                this.trajectory.modifyLastStateCode(stateCode);
+        }
+
+        public void undoUntilRoot() {
+                long start = System.nanoTime();
+                try {
+                        engine.delayUpdatePropagation(() -> {
+                                while (trajectory.canStepBack()) {
+                                        domain.getCommandStack().undo();
+                                        trajectory.backtrack();
+                                }
+                                return null;
+                        });
+                } catch (InvocationTargetException e) {
+                        throw new RuntimeException(e);
+                }
+                backtrackingTime += System.nanoTime() - start;
+                updateActivationCodes();
+                logger.debug("Backtracked to root.");
+        }
+
+        private Object generateMatchCode(IPatternMatch match) {
+                return stateCoder.createActivationCode(match);
+        }
+
+        public Object getCurrentState() {
+                return trajectory.getCurrentStateId();
+        }
+
+        public SolutionTrajectory createSolutionTrajectroy() {
+                return trajectory.createSolutionTrajectory(context.getGlobalContext().getStateCoderFactory(), this);
+        }
+
+        public TrajectoryInfo getTrajectoryInfo() {
+                return trajectory;
+        }
+
+        public void setDesignSpace(IDesignSpace designSpace) {
+                this.designSpace = designSpace;
+        }
+
+        public IDesignSpace getDesignSpace() {
+                return designSpace;
+        }
+
+        public void registerExploreEventHandler(IExploreEventHandler handler) {
+                if (handler == null) {
+                        return;
+                }
+                if (handlers == null) {
+                        handlers = new ArrayList<IExploreEventHandler>();
+                }
+                handlers.add(handler);
+        }
+
+        public void deregisterExploreEventHandler(IExploreEventHandler handler) {
+                if (handler == null) {
+                        return;
+                }
+                if (handlers != null) {
+                        handlers.remove(handler);
+                }
+        }
+
+        public void registerActivationCostProcessor(String name, BatchTransformationRule<?, ?> rule,
+                        ActivationFitnessProcessor activationFitnessProcessor) {
+                if (activationFitnessProcessors == null || activationFitnessProcessorNames == null) {
+                        activationFitnessProcessors = new HashMap<BatchTransformationRule<?, ?>, ActivationFitnessProcessor>();
+                        activationFitnessProcessorNames = new HashMap<BatchTransformationRule<?, ?>, String>();
+                }
+                activationFitnessProcessors.put(rule, activationFitnessProcessor);
+                activationFitnessProcessorNames.put(rule, name);
+        }
+
+        public boolean isCurentStateInTrajectory() {
+                Object currentStateId = trajectory.getCurrentStateId();
+                List<Object> stateTrajectory = trajectory.getStateTrajectory();
+                int size = stateTrajectory.size();
+                for (int i = 0; i < size - 1; i++) {
+                        Object stateId = stateTrajectory.get(i);
+                        if (currentStateId.equals(stateId)) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+
+        public IStateCoder getStateCoder() {
+                return stateCoder;
+        }
+
+        private void updateActivationCodes() {
+                activationCodes.updateActivationCodes();
+        }
+        
+        public long getForwardTime() {
+                return forwardTime;
+        }
+
+        public long getBacktrackingTime() {
+                return backtrackingTime;
+        }
+        
+        @Override
+        public void forwardWorked(long nanos) {
+                forwardTime += nanos;
+        }
+
+        @Override
+        public void backtrackWorked(long nanos) {
+                backtrackingTime += nanos;
+        }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DseConflictResolver.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DseConflictResolver.java
new file mode 100644
index 00000000..35504b56
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DseConflictResolver.java
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.base;
+
+import org.eclipse.viatra.dse.statecode.IStateCoder;
+import org.eclipse.viatra.transformation.evm.api.resolver.ChangeableConflictSet;
+import org.eclipse.viatra.transformation.evm.api.resolver.ConflictResolver;
+
+public class DseConflictResolver implements ConflictResolver {
+
+    private ConflictResolver activationOrderingconflictResolver;
+    private IStateCoder stateCoder;
+    private DseConflictSet lastCreatedConflictSet;
+
+    public DseConflictResolver(ConflictResolver activationOrderingConflictResolver, IStateCoder stateCoder) {
+        this.activationOrderingconflictResolver = activationOrderingConflictResolver;
+        this.stateCoder = stateCoder;
+    }
+
+    @Override
+    public ChangeableConflictSet createConflictSet() {
+        lastCreatedConflictSet = new DseConflictSet(this, activationOrderingconflictResolver, stateCoder);
+        return lastCreatedConflictSet;
+    }
+
+    public DseConflictSet getLastCreatedConflictSet() {
+        return lastCreatedConflictSet;
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DseConflictSet.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DseConflictSet.java
new file mode 100644
index 00000000..cba595f4
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DseConflictSet.java
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.base;
+
+import java.util.Set;
+
+import org.eclipse.viatra.dse.statecode.IStateCoder;
+import org.eclipse.viatra.transformation.evm.api.Activation;
+import org.eclipse.viatra.transformation.evm.api.resolver.ChangeableConflictSet;
+import org.eclipse.viatra.transformation.evm.api.resolver.ConflictResolver;
+
+public class DseConflictSet implements ChangeableConflictSet {
+
+    private ActivationCodesConflictSet activationCodesConflictSet;
+    private ChangeableConflictSet activationOrderingConflictSet;
+    private ChangeableConflictSet prevActivationOrderingConflictSet;
+    private ConflictResolver resolver;
+
+    public DseConflictSet(ConflictResolver resolver, ConflictResolver activationOrderingConflictResolver,
+            IStateCoder stateCoder) {
+        this.resolver = resolver;
+        activationOrderingConflictSet = activationOrderingConflictResolver.createConflictSet();
+        activationCodesConflictSet = new ActivationCodesConflictSet(activationOrderingConflictSet, stateCoder);
+    }
+
+    @Override
+    public Activation<?> getNextActivation() {
+        return activationOrderingConflictSet.getNextActivation();
+    }
+
+    @Override
+    public Set<Activation<?>> getNextActivations() {
+        return activationOrderingConflictSet.getNextActivations();
+    }
+
+    @Override
+    public Set<Activation<?>> getConflictingActivations() {
+        return activationOrderingConflictSet.getConflictingActivations();
+    }
+
+    @Override
+    public ConflictResolver getConflictResolver() {
+        return resolver;
+    }
+
+    @Override
+    public boolean addActivation(Activation<?> activation) {
+        activationCodesConflictSet.addActivation(activation);
+        return activationOrderingConflictSet.addActivation(activation);
+    }
+
+    @Override
+    public boolean removeActivation(Activation<?> activation) {
+        activationCodesConflictSet.removeActivation(activation);
+        return activationOrderingConflictSet.removeActivation(activation);
+    }
+
+    public ActivationCodesConflictSet getActivationCodesConflictSet() {
+        return activationCodesConflictSet;
+    }
+
+    public void changeActivationOrderingConflictSet(ChangeableConflictSet newActivationOrderingConflictSet) {
+        for (Activation<?> activation : activationOrderingConflictSet.getConflictingActivations()) {
+            newActivationOrderingConflictSet.addActivation(activation);
+        }
+        activationCodesConflictSet.reinitWithActivations(newActivationOrderingConflictSet);
+        ChangeableConflictSet tmp = activationOrderingConflictSet;
+        activationOrderingConflictSet = newActivationOrderingConflictSet;
+        prevActivationOrderingConflictSet = tmp;
+    }
+
+    public void changeActivationOrderingConflictSetBack() {
+        ChangeableConflictSet newActivationOrderingConflictSet =
+                prevActivationOrderingConflictSet.getConflictResolver().createConflictSet();
+        changeActivationOrderingConflictSet(newActivationOrderingConflictSet);
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DseEvmRuleBase.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DseEvmRuleBase.java
new file mode 100644
index 00000000..838c1d1b
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DseEvmRuleBase.java
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.base;
+
+import org.eclipse.viatra.transformation.evm.api.Agenda;
+import org.eclipse.viatra.transformation.evm.api.RuleBase;
+import org.eclipse.viatra.transformation.evm.api.event.EventRealm;
+
+public class DseEvmRuleBase extends RuleBase {
+
+    public DseEvmRuleBase(EventRealm eventRealm, Agenda agenda) {
+        super(eventRealm, agenda);
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DseIdPoolHelper.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DseIdPoolHelper.java
new file mode 100644
index 00000000..f6fee7be
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/DseIdPoolHelper.java
@@ -0,0 +1,68 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.base;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.eclipse.viatra.dse.api.DSEException;
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule;
+
+public enum DseIdPoolHelper {
+
+    INSTANCE;
+    
+    public static interface IGetRuleExecutions {
+        int getRuleExecutions(BatchTransformationRule<?, ?> rule);
+    }
+
+    public static class IdProvider {
+
+        private final BatchTransformationRule<?, ?> rule;
+        private IGetRuleExecutions getRuleExecutions;
+
+        public IdProvider(IGetRuleExecutions getRuleExecutions, BatchTransformationRule<?, ?> rule) {
+            this.getRuleExecutions = getRuleExecutions;
+            this.rule = rule;
+        }
+
+        public int getId() {
+            return getRuleExecutions.getRuleExecutions(rule);
+        }
+
+    }
+
+    private ConcurrentHashMap<Thread, HashMap<BatchTransformationRule<?, ?>, IdProvider>> idProviders = new ConcurrentHashMap<>();
+
+    public int getId(BatchTransformationRule<?, ?> rule) {
+        Thread currentThread = Thread.currentThread();
+        HashMap<BatchTransformationRule<?, ?>, IdProvider> ruleMap = idProviders.get(currentThread);
+        if (ruleMap == null) {
+            throw new DSEException("There is no registered id provider");
+        }
+        IdProvider idProvider = ruleMap.get(rule);
+        return idProvider.getId();
+    }
+
+    public void registerRules(IGetRuleExecutions getRuleExecutions, Collection<BatchTransformationRule<?, ?>> rules) {
+        Thread currentThread = Thread.currentThread();
+        HashMap<BatchTransformationRule<?, ?>, IdProvider> ruleMap = new HashMap<>();
+        for (BatchTransformationRule<?, ?> rule : rules) {
+            IdProvider idProvider = new IdProvider(getRuleExecutions, rule);
+            ruleMap.put(rule, idProvider);
+        }
+        idProviders.put(currentThread, ruleMap);
+    }
+
+    public void disposeByThread() {
+        Thread currentThread = Thread.currentThread();
+        idProviders.remove(currentThread);
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/ExplorerThread.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/ExplorerThread.java
new file mode 100644
index 00000000..f2231e5c
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/ExplorerThread.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.base;
+
+import org.apache.log4j.Logger;
+import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.transformation.evm.api.RuleEngine;
+
+/**
+ * This class implements the {@link Runnable} interface, to able to run an exploration strategy in a separate thread. It
+ * is also responsible to initialize the exploration, start the exploration (call the {@link IStrategy#explore()}
+ * method), catch any exception during exploration and to shutdown the thread correctly.
+ * 
+ * @author Földenyi Miklos & Nagy Andras Szabolcs
+ * 
+ */
+public class ExplorerThread implements Runnable {
+
+    private final ThreadContext threadContext;
+
+    private IStrategy strategy;
+
+    public ExplorerThread(final ThreadContext context) {
+        this.threadContext = context;
+        strategy = threadContext.getStrategy();
+    }
+
+    /**
+     * Signals the {@link IStrategy} instance that execution should be stopped. By contract, the strategy is to
+     * stop execution at the next stage of execution where stopping and exiting is appropriate.
+     */
+    public void stopRunning() {
+        strategy.interruptStrategy();
+    }
+
+    /**
+     * Starts the design space exploration. Returns only when the {@link IStrategy#explore()} method returns.
+     */
+    public void run() {
+        GlobalContext globalContext = threadContext.getGlobalContext();
+        try {
+            
+            threadContext.init();
+
+            strategy.initStrategy(threadContext);
+
+            strategy.explore();
+
+            threadContext.backtrackUntilRoot();
+
+        } catch (Throwable e) {
+            Logger.getLogger(IStrategy.class).error("Thread stopped unexpectedly!", e);
+            globalContext.registerException(e);
+        } finally {
+            globalContext.strategyFinished(this);
+            dispose();
+        }
+    }
+
+    /**
+     * Disposes of this strategy. Recursively calls dispose on the underlying {@link RuleEngine} and
+     * {@link ViatraQueryEngine}. Calling this is only required if the design space exploration was launched in thread, as
+     * the underlying engines get collected on the stop of the running {@link Thread}.
+     */
+    public void dispose() {
+        threadContext.getRuleEngine().dispose();
+        DseIdPoolHelper.INSTANCE.disposeByThread();
+    }
+
+    /**
+     * Returns the associated {@link ThreadContext} that houses all the thread specific data about the exploration
+     * process, and is also the gateway to the {@link GlobalContext} which stores data relevant to the design space
+     * exploration process as a whole.
+     * 
+     * @return the relevant {@link ThreadContext}.
+     */
+    public ThreadContext getThreadContext() {
+        return threadContext;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/GlobalContext.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/GlobalContext.java
new file mode 100644
index 00000000..7325ead3
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/GlobalContext.java
@@ -0,0 +1,374 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.base;
+
+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 java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy;
+import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategyFactory;
+import org.eclipse.viatra.dse.designspace.api.IDesignSpace;
+import org.eclipse.viatra.dse.multithreading.DSEThreadPool;
+import org.eclipse.viatra.dse.objectives.IGlobalConstraint;
+import org.eclipse.viatra.dse.objectives.IObjective;
+import org.eclipse.viatra.dse.objectives.LeveledObjectivesHelper;
+import org.eclipse.viatra.dse.solutionstore.SolutionStore;
+import org.eclipse.viatra.dse.statecode.IStateCoderFactory;
+import org.eclipse.viatra.dse.util.EMFHelper;
+import org.eclipse.viatra.dse.visualizer.IDesignSpaceVisualizer;
+import org.eclipse.viatra.transformation.evm.api.RuleSpecification;
+import org.eclipse.viatra.transformation.evm.api.resolver.ConflictResolver;
+import org.eclipse.viatra.transformation.evm.specific.ConflictResolvers;
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+/**
+ * Creates new contexts for strategies. It is needed because of the multithreading.
+ * 
+ * @author Andras Szabolcs Nagy
+ * 
+ */
+public class GlobalContext {
+
+    // **** fields and methods for multi threading *****//
+    // *************************************************//
+
+    public enum ExplorationProcessState {
+        NOT_STARTED,
+        RUNNING,
+        STOPPING,
+        COMPLETED
+    }
+
+    private ConcurrentLinkedQueue<Throwable> exceptions = new ConcurrentLinkedQueue<Throwable>();
+
+    private volatile ExplorationProcessState state = ExplorationProcessState.NOT_STARTED;
+    private final Set<ExplorerThread> runningThreads = new HashSet<ExplorerThread>();
+    private DSEThreadPool threadPool = new DSEThreadPool();
+    private int numberOfStartedThreads = 0;
+    private IDesignSpace designSpace;
+
+    private AtomicBoolean firstThreadContextInited = new AtomicBoolean(false);
+    private AtomicBoolean firstThreadContextIniting = new AtomicBoolean(false);
+
+    private Map<RuleSpecification<?>, BatchTransformationRule<?,?>> specificationRuleMap;
+
+    private Object terminationSnycObject = new Object();
+
+    private Logger logger = Logger.getLogger(IStrategy.class);
+
+    private boolean isAlreadyInited;
+
+    public void waitForTermination() {
+        synchronized (terminationSnycObject) {
+            while (!isDone()) {
+                try {
+                    terminationSnycObject.wait();
+                } catch (InterruptedException e) {
+                }
+            }
+        }
+    }
+
+    /**
+     * Starts a new thread to explore the design space.
+     * 
+     * @param originalThreadContext The context of the thread which starts the new thread.
+     * @param model The model to start from.
+     * @param cloneModel It should be true in most cases.
+     * @param strategy The strategy, the thread will use.
+     * @return The {@link ExplorerThread}
+     */
+    private synchronized ExplorerThread tryStartNewThread(ThreadContext originalThreadContext, Notifier model,
+            IStrategy strategy) {
+        
+        if(!isAlreadyInited) {
+            isAlreadyInited = true;
+            init();
+        }
+
+        if (state != ExplorationProcessState.COMPLETED && state != ExplorationProcessState.STOPPING
+                && threadPool.canStartNewThread()) {
+
+            ThreadContext newThreadContext = new ThreadContext(this, strategy, model);
+
+            // TODO : clone undo list? slave strategy can't go further back...
+            ExplorerThread explorerThread = new ExplorerThread(newThreadContext);
+            newThreadContext.setExplorerThread(explorerThread);
+
+            boolean isSuccessful = threadPool.tryStartNewStrategy(explorerThread);
+
+            if (isSuccessful) {
+                runningThreads.add(explorerThread);
+
+                state = ExplorationProcessState.RUNNING;
+                ++numberOfStartedThreads;
+
+                logger.info("New thread started, active threads: " + runningThreads.size());
+
+                return explorerThread;
+            }
+        }
+        return null;
+    }
+
+    public synchronized ExplorerThread tryStartNewThread(ThreadContext originalThreadContext, IStrategy strategy) {
+        return tryStartNewThread(originalThreadContext, EMFHelper.clone(originalThreadContext.getModel()), strategy);
+    }
+
+    public synchronized ExplorerThread tryStartNewThreadWithoutModelClone(ThreadContext originalThreadContext,
+            IStrategy strategy) {
+        return tryStartNewThread(originalThreadContext, originalThreadContext.getModel(), strategy);
+    }
+
+    public synchronized ExplorerThread startFirstThread(IStrategy strategy, Notifier model) {
+        Preconditions.checkState(!isAlreadyInited, "First thread is already started.");
+        return tryStartNewThread(null, EMFHelper.clone(model), strategy);
+    }
+
+    public synchronized ExplorerThread startFirstThreadWithoutModelClone(IStrategy strategy, Notifier model) {
+        Preconditions.checkState(!isAlreadyInited, "First thread is already started.");
+        return tryStartNewThread(null, model, strategy);
+    }
+    
+    public synchronized void startAllThreads(ThreadContext originalThreadContext, IStrategyFactory strategyFactory) {
+        while (canStartNewThread()) {
+            tryStartNewThread(originalThreadContext, strategyFactory.createStrategy());
+        }
+    }
+
+    /**
+     * Starts a new thread to explore the design space.
+     * 
+     * @param strategyBase
+     *            The {@link Strategy}.
+     * @param tedToClone
+     *            The model to clone. Hint: context.getTed()
+     */
+
+    public synchronized void strategyFinished(ExplorerThread strategy) {
+        runningThreads.remove(strategy);
+
+        logger.info("Thread finished, active threads: " + runningThreads.size());
+
+        // is the first part necessary?
+        if (runningThreads.isEmpty()) {
+            state = ExplorationProcessState.COMPLETED;
+            threadPool.shutdown();
+
+            // if the main thread (which started the exploration)
+            // is waiting for the solution, than wake it up
+            synchronized (terminationSnycObject) {
+                terminationSnycObject.notify();
+                logger.info("Exploration terminated.");
+            }
+
+        }
+    }
+
+    public synchronized boolean isDone() {
+        return state == ExplorationProcessState.COMPLETED && runningThreads.isEmpty();
+    }
+
+    public synchronized boolean isNotStarted() {
+        return state == ExplorationProcessState.NOT_STARTED;
+    }
+
+    public boolean canStartNewThread() {
+        return (state == ExplorationProcessState.NOT_STARTED || state == ExplorationProcessState.RUNNING)
+                && threadPool.canStartNewThread();
+    }
+
+    public synchronized void stopAllThreads() {
+        if (state == ExplorationProcessState.RUNNING) {
+            state = ExplorationProcessState.STOPPING;
+            logger.info("Stopping all threads.");
+            for (ExplorerThread strategy : runningThreads) {
+                strategy.stopRunning();
+            }
+        }
+    }
+
+    public void registerException(Throwable e) {
+        exceptions.add(e);
+    }
+
+    // ******* fields and methods for exploration *******//
+    // **************************************************//
+
+    private List<IObjective> objectives = new ArrayList<IObjective>();
+    private IObjective[][] leveledObjectives;
+    private List<IGlobalConstraint> globalConstraints = new ArrayList<IGlobalConstraint>();
+    private Set<BatchTransformationRule<?, ?>> transformations = new HashSet<BatchTransformationRule<?, ?>>();
+    private IStateCoderFactory stateCoderFactory;
+    private SolutionStore solutionStore = new SolutionStore(1);
+    private Object sharedObject;
+    private List<IDesignSpaceVisualizer> visualizers;
+
+    private ConflictResolver conflictResolver = ConflictResolvers.createArbitraryResolver();
+
+    private void init() {
+        leveledObjectives = new LeveledObjectivesHelper(objectives).initLeveledObjectives();
+        
+        specificationRuleMap = new HashMap<>();
+        for (BatchTransformationRule<?,?> rule : transformations) {
+            specificationRuleMap.put(rule.getRuleSpecification(), rule);
+        }
+    }
+
+    public List<IDesignSpaceVisualizer> getVisualizers() {
+        return ImmutableList.copyOf(visualizers);
+    }
+
+    public void registerDesignSpaceVisualizer(IDesignSpaceVisualizer visualizer) {
+        if (visualizer == null) {
+            return;
+        }
+        if (visualizers == null) {
+            visualizers = new ArrayList<IDesignSpaceVisualizer>();
+        }
+        visualizers.add(visualizer);
+    }
+
+    public void deregisterDesignSpaceVisualizer(IDesignSpaceVisualizer visualizer) {
+        if (visualizer == null) {
+            return;
+        }
+        if (visualizers != null) {
+            visualizers.remove(visualizer);
+        }
+    }
+
+    public boolean isDesignSpaceVisualizerRegistered(IDesignSpaceVisualizer visualizer) {
+        if (visualizers != null) {
+            return visualizers.contains(visualizer);
+        }
+        return false;
+    }
+
+    public void initVisualizersForThread(ThreadContext threadContext) {
+        if (visualizers != null && !visualizers.isEmpty()) {
+            for (IDesignSpaceVisualizer visualizer : visualizers) {
+                visualizer.init(threadContext);
+                threadContext.getDesignSpaceManager().registerExploreEventHandler(visualizer);
+            }
+        }
+    }
+
+    public boolean isExceptionHappendInOtherThread() {
+        return !exceptions.isEmpty();
+    }
+
+    public Collection<Throwable> getExceptions() {
+        return exceptions;
+    }
+
+    public IStateCoderFactory getStateCoderFactory() {
+        return stateCoderFactory;
+    }
+
+    public void setStateCoderFactory(IStateCoderFactory stateCoderFactory) {
+        this.stateCoderFactory = stateCoderFactory;
+    }
+
+    public Set<BatchTransformationRule<?, ?>> getTransformations() {
+        return transformations;
+    }
+
+    public void setTransformations(Set<BatchTransformationRule<?, ?>> transformations) {
+        this.transformations = transformations;
+    }
+
+    public DSEThreadPool getThreadPool() {
+        return threadPool;
+    }
+
+    public IDesignSpace getDesignSpace() {
+        return designSpace;
+    }
+
+    public void setDesignSpace(IDesignSpace designSpace) {
+        this.designSpace = designSpace;
+    }
+
+    public int getNumberOfStartedThreads() {
+        return numberOfStartedThreads;
+    }
+
+    public Object getSharedObject() {
+        return sharedObject;
+    }
+
+    public void setSharedObject(Object sharedObject) {
+        this.sharedObject = sharedObject;
+    }
+
+    public ExplorationProcessState getState() {
+        return state;
+    }
+
+    public List<IObjective> getObjectives() {
+        return objectives;
+    }
+
+    public void setObjectives(List<IObjective> objectives) {
+        this.objectives = objectives;
+    }
+
+    public List<IGlobalConstraint> getGlobalConstraints() {
+        return globalConstraints;
+    }
+
+    public void setGlobalConstraints(List<IGlobalConstraint> globalConstraints) {
+        this.globalConstraints = globalConstraints;
+    }
+
+    AtomicBoolean getFirstThreadContextInited() {
+        return firstThreadContextInited;
+    }
+
+    AtomicBoolean getFirstThreadContextIniting() {
+        return firstThreadContextIniting;
+    }
+
+    public IObjective[][] getLeveledObjectives() {
+        return leveledObjectives;
+    }
+
+    public void setSolutionStore(SolutionStore solutionStore) {
+        this.solutionStore = solutionStore;
+    }
+
+    public SolutionStore getSolutionStore() {
+        return solutionStore;
+    }
+
+    public Map<RuleSpecification<?>, BatchTransformationRule<?, ?>> getSpecificationRuleMap() {
+        return specificationRuleMap;
+    }
+
+    public void setConflictResolver(ConflictResolver conflictResolver) {
+        this.conflictResolver = conflictResolver;
+    }
+
+    public ConflictResolver getConflictResolver() {
+        return conflictResolver;
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/IDseStrategyContext.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/IDseStrategyContext.java
new file mode 100644
index 00000000..d630964f
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/IDseStrategyContext.java
@@ -0,0 +1,117 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.base;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.edit.domain.EditingDomain;
+import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy;
+import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategyFactory;
+import org.eclipse.viatra.dse.designspace.api.IDesignSpace;
+import org.eclipse.viatra.dse.designspace.api.TrajectoryInfo;
+import org.eclipse.viatra.dse.objectives.Fitness;
+import org.eclipse.viatra.dse.objectives.IGlobalConstraint;
+import org.eclipse.viatra.dse.objectives.IObjective;
+import org.eclipse.viatra.dse.objectives.ObjectiveComparatorHelper;
+import org.eclipse.viatra.dse.solutionstore.SolutionStore;
+import org.eclipse.viatra.dse.statecode.IStateCoder;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.transformation.evm.api.Activation;
+import org.eclipse.viatra.transformation.evm.api.RuleEngine;
+import org.eclipse.viatra.transformation.evm.api.RuleSpecification;
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule;
+
+/**
+ * This interface is only to overview the required methods for exploration strategies. It is not used explicitly.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public interface IDseStrategyContext {
+
+    void init();
+    
+    Notifier getModel();
+    EditingDomain getEditingDomain();
+    ViatraQueryEngine getQueryEngine();
+    RuleEngine getRuleEngine();
+    IStrategy getStrategy();
+    ExplorerThread getExplorerThread();
+    List<IObjective> getObjectives();
+    IObjective[][] getLeveledObjectives();
+    List<IGlobalConstraint> getGlobalConstraints();
+    
+    SolutionStore getSolutionStore();
+    void newSolution();
+// TODO void newSolution(TrajectoryFitness trajectoryFitness);
+    
+    
+    ObjectiveComparatorHelper getObjectiveComparatorHelper();
+
+    GlobalContext getGlobalContext();
+    Set<BatchTransformationRule<?, ?>> getRules();
+    BatchTransformationRule<?, ?> getRuleByRuleSpecification(RuleSpecification<?> ruleSpecification);
+    ExplorerThread tryStartNewThread(IStrategy strategy); /*IDseStrategyContext originalContext*/
+    ExplorerThread tryStartNewThreadWithoutModelClone(IStrategy strategy);
+    void startAllThreads(IStrategyFactory strategyFactory);
+    Object getSharedObject();
+    void setSharedObject(Object sharedObject);
+    
+    
+    DesignSpaceManager getDesignSpaceManager();
+    IStateCoder getStateCoder();
+    IDesignSpace getDesignSpace();
+    TrajectoryInfo getTrajectoryInfo();
+    List<Object> getTrajectory();
+    List<Object> getTrajectoryCopied();
+    int getDepth();
+    Object getCurrentStateId();
+
+    Object getTransitionByActivation(Activation<?> activation);
+    Activation<?> getActivationById(Object activationId);
+    BatchTransformationRule<?, ?> getRuleByActivation(Activation<?> activation);
+    BatchTransformationRule<?, ?> getRuleByActivationId(Object activationId);
+    
+    Collection<Object> getCurrentActivationIds();
+    Collection<Object> getUntraversedActivationIds();
+// TODO Object getArbitraryActivationId();
+// TODO Object getArbitraryUntraversedActivationId();
+
+    void executeAcitvationId(Object activationId);
+    boolean tryExecuteAcitvationId(Object activationId);
+    boolean executeRandomActivationId();
+    void executeTrajectory(Object[] activationIds);
+    void executeTrajectory(Object[] activationIds, int fromIncludedIndex, int toExcludedIndex);
+    int executeTrajectoryByTrying(Object[] activationIds);
+    int executeTrajectoryByTrying(Object[] activationIds, int fromIncludedIndex, int toExcludedIndex);
+    int executeTrajectoryWithoutStateCoding(Object[] activationIds);
+    int executeTrajectoryWithoutStateCoding(Object[] activationIds, int fromIncludedIndex, int toExcludedIndex);
+    int executeTrajectoryByTryingWithoutStateCoding(Object[] activationIds);
+    int executeTrajectoryByTryingWithoutStateCoding(Object[] activationIds, int fromIncludedIndex, int toExcludedIndex);
+    void executeTrajectoryWithMinimalBacktrack(Object[] trajectory);
+    void executeTrajectoryWithMinimalBacktrack(Object[] trajectory, int toExcludedIndex);
+    void executeTrajectoryWithMinimalBacktrackWithoutStateCoding(Object[] trajectory);
+    void executeTrajectoryWithMinimalBacktrackWithoutStateCoding(Object[] trajectory, int toExcludedIndex);
+
+    boolean backtrack();
+ // TODO int backtrack(int times);
+    void backtrackUntilLastCommonActivation(Object[] trajectory);
+    void backtrackUntilRoot();
+
+    Fitness calculateFitness();
+    Fitness getLastFitness();
+    boolean checkGlobalConstraints();
+    boolean isCurrentStateAlreadyTraversed();
+    // this needs states stored:
+    boolean isCurrentStateInTrajectory();
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/SingletonSetConflictResolver.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/SingletonSetConflictResolver.java
new file mode 100644
index 00000000..8c0a715a
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/SingletonSetConflictResolver.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.base;
+
+import org.eclipse.viatra.transformation.evm.api.RuleEngine;
+import org.eclipse.viatra.transformation.evm.api.resolver.ChangeableConflictSet;
+import org.eclipse.viatra.transformation.evm.api.resolver.ConflictResolver;
+
+/**
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class SingletonSetConflictResolver implements ConflictResolver {
+
+    protected ChangeableConflictSet conflictSet;
+    protected ConflictResolver conflictResolver;
+    protected ConflictResolver prevConflictResolver;
+    protected RuleEngine ruleEngine;
+
+    public SingletonSetConflictResolver(ConflictResolver conflictResolver) {
+        this.conflictResolver = conflictResolver;
+        conflictSet = conflictResolver.createConflictSet();
+    }
+
+    @Override
+    public ChangeableConflictSet createConflictSet() {
+        return conflictSet;
+    }
+
+    public void changeConflictResolver(ConflictResolver conflictResolver) {
+        ConflictResolver tmp = this.conflictResolver;
+        this.conflictResolver = conflictResolver;
+        prevConflictResolver = tmp;
+        conflictSet = conflictResolver.createConflictSet();
+        ruleEngine.setConflictResolver(this);
+    }
+
+    public void changeConflictResolverBack() {
+        changeConflictResolver(prevConflictResolver);
+    }
+
+    public void setRuleEngine(RuleEngine ruleEngine) {
+        this.ruleEngine = ruleEngine;
+        ruleEngine.setConflictResolver(this);
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/ThreadContext.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/ThreadContext.java
new file mode 100644
index 00000000..b62442ce
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/base/ThreadContext.java
@@ -0,0 +1,542 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.base;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.edit.domain.EditingDomain;
+import org.eclipse.viatra.dse.api.DSEException;
+import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy;
+import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategyFactory;
+import org.eclipse.viatra.dse.designspace.api.IDesignSpace;
+import org.eclipse.viatra.dse.designspace.api.TrajectoryInfo;
+import org.eclipse.viatra.dse.objectives.Fitness;
+import org.eclipse.viatra.dse.objectives.IGlobalConstraint;
+import org.eclipse.viatra.dse.objectives.IObjective;
+import org.eclipse.viatra.dse.objectives.ObjectiveComparatorHelper;
+import org.eclipse.viatra.dse.solutionstore.SolutionStore;
+import org.eclipse.viatra.dse.statecode.IStateCoder;
+import org.eclipse.viatra.dse.util.EMFHelper;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.emf.EMFScope;
+import org.eclipse.viatra.query.runtime.exception.ViatraQueryException;
+import org.eclipse.viatra.query.runtime.matchers.util.Preconditions;
+import org.eclipse.viatra.transformation.evm.api.Activation;
+import org.eclipse.viatra.transformation.evm.api.RuleEngine;
+import org.eclipse.viatra.transformation.evm.api.RuleSpecification;
+import org.eclipse.viatra.transformation.evm.api.event.EventFilter;
+import org.eclipse.viatra.transformation.evm.api.resolver.ChangeableConflictSet;
+import org.eclipse.viatra.transformation.evm.api.resolver.ConflictResolver;
+import org.eclipse.viatra.transformation.evm.api.resolver.ConflictSet;
+import org.eclipse.viatra.transformation.evm.specific.RuleEngines;
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule;
+
+/**
+ * This class holds all the information that is related to a single processing thread of the DesignSpaceExploration
+ * process. For any attributes related to the Design Space Exploration process as a whole, see {@link GlobalContext}.
+ * 
+ * @author Miklos Foldenyi
+ * 
+ */
+public class ThreadContext implements IDseStrategyContext{
+
+    private final GlobalContext globalContext;
+    private final IStrategy strategy;
+    private ExplorerThread explorerThread;
+    private RuleEngine ruleEngine;
+    private ViatraQueryEngine queryEngine;
+    private EditingDomain domain;
+    private Notifier model;
+    private DesignSpaceManager designSpaceManager;
+    private List<IObjective> objectives;
+    private List<IGlobalConstraint> globalConstraints;
+    private Fitness lastFitness;
+    private ObjectiveComparatorHelper objectiveComparatorHelper;
+    private IStateCoder stateCoder;
+    private DseConflictResolver dseConflictResolver;
+    private DseConflictSet dseConflictSet;
+    private ActivationCodesConflictSet activationCodesConflictSet;
+
+    /**
+     * This value is true after the {@link ThreadContext} has been initialized in it's own thread.
+     */
+    private AtomicBoolean inited = new AtomicBoolean(false);
+
+    private boolean isFirstThread = false;
+    private IObjective[][] leveledObjectives;
+    
+    private static class GetRuleExecutionsImpl implements DseIdPoolHelper.IGetRuleExecutions {
+
+        private List<BatchTransformationRule<?, ?>> executedRules;
+
+        public GetRuleExecutionsImpl(List<BatchTransformationRule<?, ?>> executedRulesView) {
+            this.executedRules = executedRulesView;
+        }
+        
+        @Override
+        public int getRuleExecutions(BatchTransformationRule<?, ?> rule) {
+            int nextId = 0;
+            for (BatchTransformationRule<?, ?> r : executedRules) {
+                if (r.equals(rule)) {
+                    nextId ++;
+                }
+            }
+            return nextId;
+        }
+        
+    }
+    
+    public DseConflictResolver getConflictResolver() {
+        return dseConflictResolver;
+    }
+
+    public ConflictSet getConflictSet() {
+        return dseConflictSet;
+    }
+
+    /**
+     * Creates a {@link ThreadContext} and sets it up to be initialized on the given {@link TransactionalEditingDomain}
+     * 
+     * @param globalContext
+     * @param strategyBase
+     * @param domain
+     * @param trajectoryInfoToClone
+     * @param parentGuidance
+     */
+    public ThreadContext(final GlobalContext globalContext, IStrategy strategy, Notifier model) {
+        Preconditions.checkArgument(model != null, "Cannot initialize ThreadContext on a null model.");
+        this.globalContext = globalContext;
+        this.strategy = strategy;
+        this.model = model;
+    }
+
+    /**
+     * Initializes the {@link ThreadContext} by initializing the underlying {@link ViatraQueryEngine} and
+     * {@link RuleEngine}. {@link Guidance} initialization is also happening within this method.
+     * 
+     * @throws DSEException
+     */
+    public void init() {
+
+        AtomicBoolean isFirst = globalContext.getFirstThreadContextIniting();
+        AtomicBoolean isFirstReady = globalContext.getFirstThreadContextInited();
+        if (!isFirstReady.get()) {
+            if (!isFirst.compareAndSet(false, true)) {
+                try {
+                    do {
+                        Thread.sleep(5);
+                    } while (!isFirstReady.get());
+                } catch (InterruptedException e) {
+                }
+            } else {
+                isFirstThread = true;
+            }
+        }
+        // prohibit re-initialization
+        Preconditions.checkArgument(!inited.getAndSet(true), "This Thread context has been initialized already!");
+
+        try {
+            // initialize query engine
+            final EMFScope scope = new EMFScope(model);
+            queryEngine = ViatraQueryEngine.on(scope);
+            
+
+            stateCoder = getGlobalContext().getStateCoderFactory().createStateCoder();
+            stateCoder.init(model);
+            stateCoder.createStateCode();
+
+            ConflictResolver activationOrderingCconflictResolver = globalContext.getConflictResolver();
+            dseConflictResolver = new DseConflictResolver(activationOrderingCconflictResolver, stateCoder);
+            
+            ruleEngine = RuleEngines.createViatraQueryRuleEngine(queryEngine);
+            ruleEngine.setConflictResolver(dseConflictResolver);
+            for (BatchTransformationRule<?, ?> tr : globalContext.getTransformations()) {
+                ruleEngine.addRule(tr.getRuleSpecification(), (EventFilter<IPatternMatch>) tr.getFilter());
+            }
+            dseConflictSet = dseConflictResolver.getLastCreatedConflictSet();
+            activationCodesConflictSet = dseConflictSet.getActivationCodesConflictSet();
+            activationCodesConflictSet.updateActivationCodes();
+
+
+        } catch (ViatraQueryException e) {
+            throw new DSEException("Failed to create unmanaged ViatraQueryEngine on the model.", e);
+        }
+
+        if (isFirstThread) {
+
+            objectives = globalContext.getObjectives();
+            leveledObjectives = globalContext.getLeveledObjectives();
+            globalConstraints = globalContext.getGlobalConstraints();
+
+        } else {
+            objectives = new ArrayList<IObjective>();
+
+            IObjective[][] leveledObjectivesToCopy = globalContext.getLeveledObjectives();
+            leveledObjectives = new IObjective[leveledObjectivesToCopy.length][];
+            for (int i = 0; i < leveledObjectivesToCopy.length; i++) {
+                leveledObjectives[i] = new IObjective[leveledObjectivesToCopy[i].length];
+                for (int j = 0; j < leveledObjectivesToCopy[i].length; j++) {
+                    leveledObjectives[i][j] = leveledObjectivesToCopy[i][j].createNew();
+                    objectives.add(leveledObjectives[i][j]);
+                }
+            }
+
+            globalConstraints = new ArrayList<IGlobalConstraint>();
+            for (IGlobalConstraint globalConstraint : globalContext.getGlobalConstraints()) {
+                globalConstraints.add(globalConstraint.createNew());
+            }
+
+        }
+        // create the thread specific DesignSpaceManager
+        this.domain = EMFHelper.createEditingDomain(model);
+        designSpaceManager = new DesignSpaceManager(this);
+
+        boolean isThereHardObjective = false;
+        for (IObjective objective : objectives) {
+            objective.init(this);
+            if (objective.isHardObjective()) {
+                isThereHardObjective = true;
+            }
+        }
+        if (!isThereHardObjective) {
+            Logger.getLogger(IStrategy.class).warn(
+                    "No hard objective is specified: all reachable state is a solution. Use a dummy hard objective to be explicit.");
+        }
+        
+        for (IGlobalConstraint globalConstraint : globalConstraints) {
+            globalConstraint.init(this);
+        }
+
+        DseIdPoolHelper.INSTANCE.registerRules(new GetRuleExecutionsImpl(getDesignSpaceManager().getTrajectoryInfo().getRules()), getRules());
+
+        globalContext.initVisualizersForThread(this);
+
+        if (isFirstThread) {
+            isFirstReady.set(true);
+        }
+
+    }
+
+    public Fitness calculateFitness() {
+        Fitness result = new Fitness();
+
+        boolean satisifiesHardObjectives = true;
+
+        for (IObjective objective : objectives) {
+            Double fitness = objective.getFitness(this);
+            result.put(objective.getName(), fitness);
+            if (objective.isHardObjective() && !objective.satisifiesHardObjective(fitness)) {
+                satisifiesHardObjectives = false;
+            }
+        }
+
+        result.setSatisifiesHardObjectives(satisifiesHardObjectives);
+
+        lastFitness = result;
+
+        return result;
+    }
+
+    public boolean checkGlobalConstraints() {
+        for (IGlobalConstraint globalConstraint : globalContext.getGlobalConstraints()) {
+            if (!globalConstraint.checkGlobalConstraint(this)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public RuleEngine getRuleEngine() {
+        return ruleEngine;
+    }
+
+    public GlobalContext getGlobalContext() {
+        return globalContext;
+    }
+
+    public DesignSpaceManager getDesignSpaceManager() {
+        return designSpaceManager;
+    }
+
+    public EditingDomain getEditingDomain() {
+        return domain;
+    }
+
+    public Notifier getModel() {
+        return model;
+    }
+
+    public ViatraQueryEngine getQueryEngine() {
+        return queryEngine;
+    }
+
+    public IStrategy getStrategy() {
+        return strategy;
+    }
+
+    public ExplorerThread getExplorerThread() {
+        return explorerThread;
+    }
+
+    public void setExplorerThread(ExplorerThread explorerThread) {
+        this.explorerThread = explorerThread;
+    }
+
+    public Fitness getLastFitness() {
+        return lastFitness;
+    }
+
+    public ObjectiveComparatorHelper getObjectiveComparatorHelper() {
+        if (objectiveComparatorHelper == null) {
+            objectiveComparatorHelper = new ObjectiveComparatorHelper(leveledObjectives);
+        }
+        return objectiveComparatorHelper;
+    }
+
+    public IObjective[][] getLeveledObjectives() {
+        return leveledObjectives;
+    }
+    
+    public List<IObjective> getObjectives() {
+        return objectives;
+    }
+    
+    public List<IGlobalConstraint> getGlobalConstraints() {
+        return globalConstraints;
+    }
+
+    @Override
+    public SolutionStore getSolutionStore() {
+        return globalContext.getSolutionStore();
+    }
+
+    @Override
+    public void newSolution() {
+        globalContext.getSolutionStore().newSolution(this);
+    }
+
+    @Override
+    public Object getSharedObject() {
+        return globalContext.getSharedObject();
+    }
+
+    @Override
+    public void setSharedObject(Object sharedObject) {
+        globalContext.setSharedObject(sharedObject);
+    }
+
+    @Override
+    public Set<BatchTransformationRule<?, ?>> getRules() {
+        return globalContext.getTransformations();
+    }
+
+    @Override
+    public BatchTransformationRule<?, ?> getRuleByRuleSpecification(RuleSpecification<?> ruleSpecification) {
+        return globalContext.getSpecificationRuleMap().get(ruleSpecification);
+    }
+
+    @Override
+    public ExplorerThread tryStartNewThread(IStrategy strategy) {
+        return globalContext.tryStartNewThread(this, strategy);
+    }
+
+    @Override
+    public ExplorerThread tryStartNewThreadWithoutModelClone(IStrategy strategy) {
+        return globalContext.tryStartNewThreadWithoutModelClone(this, strategy);
+    }
+
+    @Override
+    public void startAllThreads(IStrategyFactory strategyFactory) {
+        globalContext.startAllThreads(this, strategyFactory);
+    }
+
+    @Override
+    public IStateCoder getStateCoder() {
+        return stateCoder;
+    }
+
+    @Override
+    public IDesignSpace getDesignSpace() {
+        return globalContext.getDesignSpace();
+    }
+
+    @Override
+    public TrajectoryInfo getTrajectoryInfo() {
+        return designSpaceManager.getTrajectoryInfo();
+    }
+
+    @Override
+    public List<Object> getTrajectory() {
+        return designSpaceManager.getTrajectoryInfo().getTrajectory();
+    }
+
+    @Override
+    public List<Object> getTrajectoryCopied() {
+        return new ArrayList<Object>(getTrajectory());
+    }
+
+    @Override
+    public int getDepth() {
+        return designSpaceManager.getTrajectoryInfo().getDepth();
+    }
+
+    @Override
+    public Object getCurrentStateId() {
+        return designSpaceManager.getTrajectoryInfo().getCurrentStateId();
+    }
+
+    @Override
+    public Object getTransitionByActivation(Activation<?> activation) {
+        return designSpaceManager.getTransitionByActivation(activation);
+    }
+
+    @Override
+    public Activation<?> getActivationById(Object activationId) {
+        return designSpaceManager.getActivationById(activationId);
+    }
+
+    @Override
+    public BatchTransformationRule<?, ?> getRuleByActivation(Activation<?> activation) {
+        return designSpaceManager.getRuleByActivation(activation);
+    }
+
+    @Override
+    public BatchTransformationRule<?, ?> getRuleByActivationId(Object activationId) {
+        return designSpaceManager.getRuleByActivationId(activationId);
+    }
+
+    @Override
+    public Collection<Object> getCurrentActivationIds() {
+        return designSpaceManager.getTransitionsFromCurrentState();
+    }
+
+    @Override
+    public Collection<Object> getUntraversedActivationIds() {
+        return designSpaceManager.getUntraversedTransitionsFromCurrentState();
+    }
+
+    @Override
+    public void executeAcitvationId(Object activationId) {
+        designSpaceManager.fireActivation(activationId);
+    }
+
+    @Override
+    public boolean tryExecuteAcitvationId(Object activationId) {
+        return designSpaceManager.tryFireActivation(activationId);
+    }
+
+    @Override
+    public boolean executeRandomActivationId() {
+        return designSpaceManager.executeRandomActivationId();
+    }
+
+    @Override
+    public void executeTrajectory(Object[] activationIds) {
+        designSpaceManager.executeTrajectory(activationIds);
+    }
+
+    @Override
+    public void executeTrajectory(Object[] activationIds, int fromIncludedIndex, int toExcludedIndex) {
+        designSpaceManager.executeTrajectory(activationIds, fromIncludedIndex, toExcludedIndex);
+    }
+
+    @Override
+    public int executeTrajectoryByTrying(Object[] activationIds) {
+        return designSpaceManager.executeTrajectoryByTrying(activationIds);
+    }
+
+    @Override
+    public int executeTrajectoryByTrying(Object[] activationIds, int fromIncludedIndex, int toExcludedIndex) {
+        return designSpaceManager.executeTrajectoryByTrying(activationIds, fromIncludedIndex, toExcludedIndex);
+    }
+
+    @Override
+    public int executeTrajectoryWithoutStateCoding(Object[] activationIds) {
+        return designSpaceManager.executeTrajectoryWithoutStateCoding(activationIds);
+    }
+
+    @Override
+    public int executeTrajectoryWithoutStateCoding(Object[] activationIds, int fromIncludedIndex, int toExcludedIndex) {
+        return designSpaceManager.executeTrajectoryWithoutStateCoding(activationIds, fromIncludedIndex, toExcludedIndex);
+    }
+
+    @Override
+    public int executeTrajectoryByTryingWithoutStateCoding(Object[] activationIds) {
+        return designSpaceManager.executeTrajectoryByTryingWithoutStateCoding(activationIds);
+    }
+
+    @Override
+    public int executeTrajectoryByTryingWithoutStateCoding(Object[] activationIds, int fromIncludedIndex, int toExcludedIndex) {
+        return designSpaceManager.executeTrajectoryByTryingWithoutStateCoding(activationIds, fromIncludedIndex, toExcludedIndex);
+    }
+
+    @Override
+    public void executeTrajectoryWithMinimalBacktrack(Object[] trajectory) {
+        designSpaceManager.executeTrajectoryWithMinimalBacktrack(trajectory);
+    }
+
+    @Override
+    public void executeTrajectoryWithMinimalBacktrack(Object[] trajectory, int toExcludedIndex) {
+        designSpaceManager.executeTrajectoryWithMinimalBacktrack(trajectory, toExcludedIndex);
+    }
+
+    @Override
+    public void executeTrajectoryWithMinimalBacktrackWithoutStateCoding(Object[] trajectory) {
+        designSpaceManager.executeTrajectoryWithMinimalBacktrackWithoutStateCoding(trajectory);
+    }
+
+    @Override
+    public void executeTrajectoryWithMinimalBacktrackWithoutStateCoding(Object[] trajectory, int toExcludedIndex) {
+        designSpaceManager.executeTrajectoryWithMinimalBacktrackWithoutStateCoding(trajectory, toExcludedIndex);
+    }
+    
+    @Override
+    public boolean backtrack() {
+        return designSpaceManager.undoLastTransformation();
+    }
+
+    @Override
+    public void backtrackUntilLastCommonActivation(Object[] trajectory) {
+        designSpaceManager.backtrackUntilLastCommonActivation(trajectory);
+    }
+
+    @Override
+    public void backtrackUntilRoot() {
+        designSpaceManager.undoUntilRoot();
+    }
+
+    @Override
+    public boolean isCurrentStateAlreadyTraversed() {
+        return designSpaceManager.isNewModelStateAlreadyTraversed();
+    }
+
+    @Override
+    public boolean isCurrentStateInTrajectory() {
+        return designSpaceManager.isCurentStateInTrajectory();
+    }
+
+    public ActivationCodesConflictSet getActivationCodesConflictSet() {
+        return activationCodesConflictSet;
+    }
+    
+    public void changeActivationOrdering(ChangeableConflictSet activationOrderingConflictSet) {
+        this.dseConflictSet.changeActivationOrderingConflictSet(activationOrderingConflictSet);
+    }
+
+    public void changeActivationOrderingBack() {
+        this.dseConflictSet.changeActivationOrderingConflictSetBack();
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/DesignSpace.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/DesignSpace.java
new file mode 100644
index 00000000..bc0f08d4
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/DesignSpace.java
@@ -0,0 +1,106 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.designspace.api;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+
+public class DesignSpace implements IDesignSpace {
+
+    Set<Object> statesView;
+
+    Set<Object> rootStates;
+    Set<Object> rootStatesView;
+
+    Map<Object, List<Object>> statesAndActivations;
+
+    Random random = new Random();
+
+    public DesignSpace() {
+        rootStates = new HashSet<>();
+        rootStatesView = Collections.unmodifiableSet(rootStates);
+
+        statesAndActivations = new HashMap<>();
+        statesView = statesAndActivations.keySet();
+    }
+
+    @Override
+    public synchronized Collection<Object> getStates() {
+        return statesView;
+    }
+
+    @Override
+    public synchronized Collection<Object> getRoots() {
+        return rootStatesView;
+    }
+
+    @Override
+    public synchronized void addState(Object sourceStateId, Object firedActivationId, Object newStateId) {
+
+        List<Object> activationIds = statesAndActivations.get(newStateId);
+
+        if (activationIds == null) {
+            activationIds = new ArrayList<Object>();
+            statesAndActivations.put(newStateId, activationIds);
+
+            if (sourceStateId == null) {
+                rootStates.add(newStateId);
+                return;
+            }
+        }
+
+        activationIds = statesAndActivations.get(sourceStateId);
+
+        if (activationIds == null) {
+            activationIds = new ArrayList<Object>();
+            activationIds.add(firedActivationId);
+            statesAndActivations.put(sourceStateId, activationIds);
+        } else {
+            activationIds.add(firedActivationId);
+        }
+    }
+
+    public synchronized boolean isTraversed(Object stateId) {
+        return statesAndActivations.containsKey(stateId);
+    }
+
+    @Override
+    public synchronized Collection<Object> getActivationIds(Object stateId) {
+        return statesAndActivations.get(stateId);
+    }
+
+    @Override
+    public synchronized Object getRandomActivationId(Object stateId) {
+        List<Object> activations = statesAndActivations.get(stateId);
+        int index = random.nextInt(activations.size());
+        return activations.get(index);
+    }
+
+    @Override
+    public synchronized long getNumberOfStates() {
+        return statesAndActivations.size();
+    }
+
+    @Override
+    public synchronized long getNumberOfTransitions() {
+        int numberOfTransitions = 0;
+        for (List<Object> activations : statesAndActivations.values()) {
+            numberOfTransitions += activations.size();
+        }
+        return numberOfTransitions;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/IBacktrackListener.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/IBacktrackListener.java
new file mode 100644
index 00000000..5c688276
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/IBacktrackListener.java
@@ -0,0 +1,7 @@
+package org.eclipse.viatra.dse.designspace.api;
+
+public interface IBacktrackListener {
+        void forwardWorked(long nanos);
+        
+        void backtrackWorked(long nanos);
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/IDesignSpace.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/IDesignSpace.java
new file mode 100644
index 00000000..a1d64bbf
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/IDesignSpace.java
@@ -0,0 +1,27 @@
+/*******************************************************************************

+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy and Daniel Varro

+ * This program and the accompanying materials are made available under the

+ * terms of the Eclipse Public License v. 2.0 which is available at

+ * http://www.eclipse.org/legal/epl-v20.html.

+ * 

+ * SPDX-License-Identifier: EPL-2.0

+ *******************************************************************************/

+package org.eclipse.viatra.dse.designspace.api;

+

+import java.util.Collection;

+

+public interface IDesignSpace {

+

+    Collection<Object> getStates();

+    Collection<Object> getRoots();

+    void addState(Object sourceStateId, Object firedActivationId, Object newStateId);

+

+    boolean isTraversed(Object stateId);

+

+    Collection<Object> getActivationIds(Object stateId);

+    Object getRandomActivationId(Object stateId);

+

+    long getNumberOfStates();

+    long getNumberOfTransitions();

+

+}

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/TrajectoryInfo.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/TrajectoryInfo.java
new file mode 100644
index 00000000..acd88416
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/designspace/api/TrajectoryInfo.java
@@ -0,0 +1,154 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.designspace.api;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import org.eclipse.viatra.dse.api.DSEException;
+import org.eclipse.viatra.dse.api.SolutionTrajectory;
+import org.eclipse.viatra.dse.base.DesignSpaceManager;
+import org.eclipse.viatra.dse.statecode.IStateCoderFactory;
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule;
+
+public class TrajectoryInfo {
+
+    private final List<Object> trajectory;
+    private final List<Object> trajectoryView;
+    private final List<BatchTransformationRule<?, ?>> rules;
+    private final List<BatchTransformationRule<?, ?>> rulesView;
+    private final List<Object> stateIds;
+    private final List<Object> stateIdsView;
+    private final List<Map<String, Double>> measuredCosts;
+
+    public TrajectoryInfo(Object initialStateId) {
+        Objects.requireNonNull(initialStateId);
+
+        stateIds = new ArrayList<>();
+        stateIds.add(initialStateId);
+
+        trajectory = new ArrayList<>();
+        rules = new ArrayList<>();
+        measuredCosts = new ArrayList<>();
+
+        trajectoryView = Collections.unmodifiableList(trajectory);
+        stateIdsView = Collections.unmodifiableList(stateIds);
+        rulesView = Collections.unmodifiableList(rules);
+    }
+
+    /**
+     * Copy constructor
+     * 
+     * @since 0.17
+     */
+    public TrajectoryInfo(TrajectoryInfo other) {
+        this(other.stateIds, other.trajectory, other.rules, other.measuredCosts);
+    }
+    
+    protected TrajectoryInfo(List<Object> stateIds, List<Object> trajectory, List<BatchTransformationRule<?, ?>> rules, List<Map<String, Double>> measuredCosts) {
+
+        this.stateIds = new ArrayList<>(stateIds);
+        this.trajectory = new ArrayList<>(trajectory);
+        this.rules = new ArrayList<>(rules);
+        trajectoryView = Collections.unmodifiableList(trajectory);
+        stateIdsView = Collections.unmodifiableList(stateIds);
+        rulesView = Collections.unmodifiableList(rules);
+        this.measuredCosts = new ArrayList<>(measuredCosts);
+    }
+
+    public void addStep(Object activationId, BatchTransformationRule<?, ?> rule, Object newStateId, Map<String, Double> measuredCosts) {
+        stateIds.add(newStateId);
+        trajectory.add(activationId);
+        rules.add(rule);
+        this.measuredCosts.add(measuredCosts);
+    }
+
+    public void backtrack() {
+        int size = trajectory.size();
+
+        if (size == 0) {
+            throw new DSEException("Cannot step back any further!");
+        }
+
+        trajectory.remove(size - 1);
+        rules.remove(size - 1);
+        stateIds.remove(size);
+        measuredCosts.remove(size - 1);
+    }
+
+    public Object getInitialStateId() {
+        return stateIds.get(0);
+    }
+
+    public Object getCurrentStateId() {
+        return stateIds.get(stateIds.size() - 1);
+    }
+
+    public Object getLastActivationId() {
+        return trajectory.get(trajectory.size() - 1);
+    }
+
+    public List<Object> getTrajectory() {
+        return trajectoryView;
+    }
+
+    public List<Object> getStateTrajectory() {
+        return stateIdsView;
+    }
+
+    public List<BatchTransformationRule<?, ?>> getRules() {
+        return rulesView;
+    }
+
+    public int getDepth() {
+        return trajectory.size();
+    }
+
+    public List<Map<String, Double>> getMeasuredCosts() {
+        return measuredCosts;
+    }
+
+    public SolutionTrajectory createSolutionTrajectory(final IStateCoderFactory stateCoderFactory, final IBacktrackListener listener) {
+
+        List<Object> activationIds = new ArrayList<>(trajectory);
+        List<BatchTransformationRule<?, ?>> copiedRules = new ArrayList<>(rules);
+
+        return new SolutionTrajectory(activationIds, copiedRules, stateCoderFactory, listener);
+    }
+
+    public boolean canStepBack() {
+        return !trajectory.isEmpty();
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("Trajectory:\n");
+        for (Object activationId : trajectory) {
+            sb.append(activationId);
+            sb.append("\n");
+        }
+        return sb.toString();
+    }
+
+    /**
+     * This method is only used by the {@link DesignSpaceManager}.
+     * @param stateCode 
+     * @return false if the initial state code is the last one, otherwise true.
+     */
+    public boolean modifyLastStateCode(Object stateCode) {
+        if (stateIds.size() == 1) {
+            return false;
+        }
+        stateIds.set(stateIds.size() - 1, stateCode);
+        return true;
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/multithreading/DSEThreadPool.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/multithreading/DSEThreadPool.java
new file mode 100644
index 00000000..17e96a75
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/multithreading/DSEThreadPool.java
@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.multithreading;
+
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.log4j.Logger;
+import org.eclipse.viatra.dse.api.DesignSpaceExplorer;
+import org.eclipse.viatra.dse.base.ExplorerThread;
+
+/**
+ * 
+ * @author Andras Szabolcs Nagy
+ * 
+ */
+public class DSEThreadPool extends ThreadPoolExecutor {
+
+    private static final long THREAD_KEEP_ALIVE_IN_SECONDS = 60;
+
+    public DSEThreadPool() {
+        // Based on the Executors.newCachedThreadPool()
+        super(0, getProcNumber(), THREAD_KEEP_ALIVE_IN_SECONDS, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
+    }
+
+    // helper for constructor
+    private static int getProcNumber() {
+        return Runtime.getRuntime().availableProcessors();
+    }
+
+    public boolean tryStartNewStrategy(ExplorerThread strategy) {
+
+        if (!canStartNewThread()) {
+            return false;
+        }
+
+        try {
+            submit(strategy);
+        } catch (RejectedExecutionException e) {
+            Logger.getLogger(DesignSpaceExplorer.class).info("Couldn't start new thread.", e);
+            return false;
+        }
+
+        return true;
+    }
+
+    public boolean canStartNewThread() {
+        return getMaximumPoolSize() > getActiveCount();
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/ActivationFitnessProcessor.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/ActivationFitnessProcessor.java
new file mode 100644
index 00000000..c06d2916
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/ActivationFitnessProcessor.java
@@ -0,0 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives;
+
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+
+public interface ActivationFitnessProcessor {
+    public double process(IPatternMatch match);
+}
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/Comparators.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/Comparators.java
new file mode 100644
index 00000000..b1bd9349
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/Comparators.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives;
+
+import java.util.Comparator;
+
+/**
+ * This helper class holds comparators for objective implementations.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class Comparators {
+
+    private Comparators() { /*Utility class constructor*/ }
+    
+    public static final Comparator<Double> HIGHER_IS_BETTER = (o1, o2) -> o1.compareTo(o2);
+
+    public static final Comparator<Double> LOWER_IS_BETTER = (o1, o2) -> o2.compareTo(o1);
+    
+    private static final Double ZERO = Double.valueOf(0);
+    
+    public static final Comparator<Double> DIFFERENCE_TO_ZERO_IS_BETTER = (o1, o2) -> ZERO.compareTo(Math.abs(o1)-Math.abs(o2));
+    
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/Fitness.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/Fitness.java
new file mode 100644
index 00000000..8beef3bd
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/Fitness.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives;
+
+import java.util.HashMap;
+
+public class Fitness extends HashMap<String, Double>{
+
+    private boolean satisifiesHardObjectives;
+    
+    public boolean isSatisifiesHardObjectives() {
+        return satisifiesHardObjectives;
+    }
+    
+    public void setSatisifiesHardObjectives(boolean satisifiesHardObjectives) {
+        this.satisifiesHardObjectives = satisifiesHardObjectives;
+    }
+    
+    @Override
+    public String toString() {
+        return super.toString() + " hardObjectives=" + satisifiesHardObjectives;
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/IGlobalConstraint.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/IGlobalConstraint.java
new file mode 100644
index 00000000..2f7f0347
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/IGlobalConstraint.java
@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+
+/**
+ * 
+ * Implementation of this interface represents a global constraint of the DSE problem, which can halt an exploration
+ * continuing from a state which dissatisfies the global constraint.
+ * <p>
+ * Certain global constraints can have inner state for the validation. In this case a new instance is necessary for
+ * every new thread, and the {@code createNew} method should not return the same instance more than once.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public interface IGlobalConstraint {
+
+    /**
+     * Returns the name of the global constraint.
+     * 
+     * @return The name of the global constraint.
+     */
+    String getName();
+
+    /**
+     * Checks whether the current state satisfies the global constraint.
+     * 
+     * @param context
+     *            The {@link ThreadContext} which contains the necessary information.
+     * @return True if the state is valid and exploration can be continued from the actual state.
+     */
+    boolean checkGlobalConstraint(ThreadContext context);
+
+    /**
+     * Initializes the global constraint. It is called exactly once for every thread starts.
+     * 
+     * @param context
+     *            The {@link ThreadContext}.
+     */
+    void init(ThreadContext context);
+
+    /**
+     * Returns an instance of the {@link IGlobalConstraint}. If it returns the same instance, all the methods has to be
+     * thread save as they are called concurrently.
+     * 
+     * @return An instance of the global constraint.
+     */
+    IGlobalConstraint createNew();
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/IObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/IObjective.java
new file mode 100644
index 00000000..849dd4e8
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/IObjective.java
@@ -0,0 +1,110 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives;
+
+import java.util.Comparator;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+
+/**
+ * 
+ * Implementation of this interface represents a single objective of the DSE problem, which can assess a solution
+ * (trajectory) in a single number. It has a name and a comparator which orders two solution based on the calculated
+ * value.
+ * <p>
+ * Objectives can be either hard or soft objectives. Hard objectives can be satisfied or unsatisfied. If all of the hard
+ * objectives are satisfied on a single solution, then it is considered to be a valid (or goal) solution.
+ * <p>
+ * Certain objectives can have inner state for calculating the fitness value. In this case a new instance is necessary
+ * for every new thread, and the {@code createNew} method should not return the same instance more than once.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public interface IObjective {
+
+    /**
+     * Returns the name of the objective.
+     * 
+     * @return The name of the objective.
+     */
+    String getName();
+
+    /**
+     * Sets the {@link Comparator} which is used to compare fitness (doubles). It determines whether the objective is to
+     * minimize or maximize (or minimize or maximize a delta from a given number).
+     * 
+     * @param comparator The comparator.
+     */
+    void setComparator(Comparator<Double> comparator);
+
+    /**
+     * Returns a {@link Comparator} which is used to compare fitness (doubles). It determines whether the objective is
+     * to minimize or maximize (or minimize or maximize a delta from a given number).
+     * 
+     * @return The comparator.
+     */
+    Comparator<Double> getComparator();
+
+    /**
+     * Calculates the value of the objective on a given solution (trajectory).
+     * 
+     * @param context
+     *            The {@link ThreadContext}
+     * @return The objective value in double.
+     */
+    Double getFitness(ThreadContext context);
+
+    /**
+     * Initializes the objective. It is called exactly once for every thread starts.
+     * 
+     * @param context
+     *            The {@link ThreadContext}.
+     */
+    void init(ThreadContext context);
+
+    /**
+     * Returns an instance of the {@link IObjective}. If it returns the same instance, all the methods has to be thread
+     * save as they are called concurrently.
+     * 
+     * @return An instance of the objective.
+     */
+    IObjective createNew();
+
+    /**
+     * Returns true if the objective is a hard objective. In such a case the method
+     * {@link IObjective#satisifiesHardObjective(Double)} is called.
+     * 
+     * @return True if the objective is a hard objective.
+     * @see IObjective#satisifiesHardObjective(Double)
+     * @see IObjective
+     */
+    boolean isHardObjective();
+
+    /**
+     * Determines if the given fitness value satisfies the hard objective.
+     * 
+     * @param fitness
+     *            The fitness value of a solution.
+     * @return True if it satisfies the hard objective or it is a soft constraint.
+     * @see IObjective
+     */
+    boolean satisifiesHardObjective(Double fitness);
+
+    /**
+     * Set the level of the objective.
+     */
+    void setLevel(int level);
+
+    /**
+     * Gets the level of the objective.
+     */
+    int getLevel();
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/LeveledObjectivesHelper.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/LeveledObjectivesHelper.java
new file mode 100644
index 00000000..2d81629b
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/LeveledObjectivesHelper.java
@@ -0,0 +1,114 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+
+public class LeveledObjectivesHelper {
+
+    private List<IObjective> objectives = new ArrayList<IObjective>();
+    private IObjective[][] leveledObjectives;
+
+    public LeveledObjectivesHelper(List<IObjective> objectives) {
+        this.objectives = objectives;
+    }
+
+    public IObjective[][] initLeveledObjectives() {
+        if (objectives.isEmpty()) {
+            leveledObjectives = new IObjective[0][0];
+            return leveledObjectives;
+        }
+
+        int level = objectives.get(0).getLevel();
+        boolean oneLevelOnly = true;
+        for (IObjective objective : objectives) {
+            if (objective.getLevel() != level) {
+                oneLevelOnly = false;
+                break;
+            }
+        }
+
+        if (oneLevelOnly) {
+            leveledObjectives = new IObjective[1][objectives.size()];
+            for (int i = 0; i < objectives.size(); i++) {
+                leveledObjectives[0][i] = objectives.get(i);
+            }
+            return leveledObjectives;
+        }
+
+        IObjective[] objectivesArray = getSortedByLevelObjectives(objectives);
+
+        int numberOfLevels = getNumberOfObjectiveLevels(objectivesArray);
+
+        leveledObjectives = new IObjective[numberOfLevels][];
+
+        fillLeveledObjectives(objectivesArray);
+
+        return leveledObjectives;
+    }
+
+    private void fillLeveledObjectives(IObjective[] objectivesArray) {
+        int actLevel = objectivesArray[0].getLevel();
+        int levelIndex = 0;
+        int lastIndex = 0;
+        int corrigationForLastLevel = 0;
+        boolean oneObjectiveAtLastLevel = false;
+        for (int i = 0; i < objectivesArray.length; i++) {
+            if (i == objectivesArray.length - 1) {
+                corrigationForLastLevel = 1;
+                if (objectivesArray[i - 1].getLevel() != objectivesArray[i].getLevel()) {
+                    oneObjectiveAtLastLevel = true;
+                    corrigationForLastLevel = 0;
+                }
+            }
+            if (objectivesArray[i].getLevel() != actLevel || corrigationForLastLevel == 1 || oneObjectiveAtLastLevel) {
+                leveledObjectives[levelIndex] = new IObjective[i - lastIndex + corrigationForLastLevel];
+                for (int j = lastIndex; j < i + corrigationForLastLevel; j++) {
+                    leveledObjectives[levelIndex][j - lastIndex] = objectivesArray[j];
+                }
+                if (oneObjectiveAtLastLevel) {
+                    leveledObjectives[levelIndex + 1] = new IObjective[1];
+                    leveledObjectives[levelIndex + 1][0] = objectivesArray[i];
+                }
+                actLevel = objectivesArray[i].getLevel();
+                levelIndex++;
+                lastIndex = i;
+            }
+        }
+    }
+
+    private int getNumberOfObjectiveLevels(IObjective[] objectivesArray) {
+
+        int actLevel = objectivesArray[0].getLevel();
+        int numberOfLevels = 1;
+
+        for (int i = 1; i < objectivesArray.length; i++) {
+            if (objectivesArray[i].getLevel() != actLevel) {
+                numberOfLevels++;
+                actLevel = objectivesArray[i].getLevel();
+            }
+        }
+
+        return numberOfLevels;
+    }
+
+    private IObjective[] getSortedByLevelObjectives(List<IObjective> objectives) {
+        IObjective[] objectivesArray = objectives.toArray(new IObjective[objectives.size()]);
+        Arrays.sort(objectivesArray, Comparator.comparingInt(IObjective::getLevel)); 
+        return objectivesArray;
+    }
+
+    public IObjective[][] getLeveledObjectives() {
+        return leveledObjectives;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/ObjectiveComparatorHelper.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/ObjectiveComparatorHelper.java
new file mode 100644
index 00000000..39139bb0
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/ObjectiveComparatorHelper.java
@@ -0,0 +1,217 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+import org.eclipse.viatra.query.runtime.matchers.util.Preconditions;
+
+/**
+ * This class is responsible to compare and sort fitness values. {@link TrajectoryFitness} instances can be added to an
+ * instance of this class, that it can sort them.
+ * 
+ * @author András Szabolcs Nagy
+ */
+public class ObjectiveComparatorHelper {
+
+    private IObjective[][] leveledObjectives;
+    private List<TrajectoryFitness> trajectoryFitnesses = new ArrayList<TrajectoryFitness>();
+    private Random random = new Random();
+    private boolean computeCrowdingDistance = false;
+
+    public ObjectiveComparatorHelper(IObjective[][] leveledObjectives) {
+        this.leveledObjectives = leveledObjectives;
+    }
+
+    public void setComputeCrowdingDistance(boolean computeCrowdingDistance) {
+        this.computeCrowdingDistance = computeCrowdingDistance;
+    }
+
+    /**
+     * Compares two fitnesses based on hierarchical dominance. Returns -1 if the second parameter {@code o2} is a better
+     * solution ({@code o2} dominates {@code o1}), 1 if the first parameter {@code o1} is better ({@code o1} dominates
+     * {@code o2}) and returns 0 if they are non-dominating each other.
+     */
+    public int compare(Fitness o1, Fitness o2) {
+
+        levelsLoop: for (int i = 0; i < leveledObjectives.length; i++) {
+
+            boolean o1HasBetterFitness = false;
+            boolean o2HasBetterFitness = false;
+
+            for (IObjective objective : leveledObjectives[i]) {
+                String objectiveName = objective.getName();
+                int sgn = objective.getComparator().compare(o1.get(objectiveName), o2.get(objectiveName));
+
+                if (sgn < 0) {
+                    o2HasBetterFitness = true;
+                }
+                if (sgn > 0) {
+                    o1HasBetterFitness = true;
+                }
+                if (o1HasBetterFitness && o2HasBetterFitness) {
+                    continue levelsLoop;
+                }
+            }
+            if (o2HasBetterFitness && !o1HasBetterFitness) {
+                return -1;
+            } else if (!o2HasBetterFitness && o1HasBetterFitness) {
+                return 1;
+            }
+        }
+
+        return 0;
+
+    }
+
+    /**
+     * Adds a {@link TrajectoryFitness} to an inner list to compare later.
+     * 
+     * @param trajectoryFitness
+     */
+    public void addTrajectoryFitness(TrajectoryFitness trajectoryFitness) {
+        trajectoryFitnesses.add(trajectoryFitness);
+    }
+
+    /**
+     * Clears the inner {@link TrajectoryFitness} list.
+     */
+    public void clearTrajectoryFitnesses() {
+        trajectoryFitnesses.clear();
+    }
+
+    /**
+     * Returns the inner {@link TrajectoryFitness} list.
+     */
+    public List<TrajectoryFitness> getTrajectoryFitnesses() {
+        return trajectoryFitnesses;
+    }
+
+    /**
+     * Returns a random {@link TrajectoryFitness} from the pareto front.
+     */
+    public TrajectoryFitness getRandomBest() {
+        List<TrajectoryFitness> paretoFront = getParetoFront();
+        int randomIndex = random.nextInt(paretoFront.size());
+        return paretoFront.get(randomIndex);
+    }
+
+    /**
+     * Returns the pareto front of the previously added {@link TrajectoryFitness}.
+     */
+    public List<TrajectoryFitness> getParetoFront() {
+        return getFronts().get(0);
+    }
+
+    /**
+     * Returns the previously added {@link TrajectoryFitness} instances in fronts.
+     */
+    public List<? extends List<TrajectoryFitness>> getFronts() {
+        Preconditions.checkArgument(!trajectoryFitnesses.isEmpty(), "No trajectory fitnesses were added.");
+        List<ArrayList<TrajectoryFitness>> fronts = new ArrayList<ArrayList<TrajectoryFitness>>();
+
+        Map<TrajectoryFitness, ArrayList<TrajectoryFitness>> dominatedInstances = new HashMap<TrajectoryFitness, ArrayList<TrajectoryFitness>>();
+        Map<TrajectoryFitness, Integer> dominatingInstances = new HashMap<TrajectoryFitness, Integer>();
+
+        // calculate dominations
+        for (TrajectoryFitness TrajectoryFitnessP : trajectoryFitnesses) {
+            dominatedInstances.put(TrajectoryFitnessP, new ArrayList<TrajectoryFitness>());
+            dominatingInstances.put(TrajectoryFitnessP, 0);
+
+            for (TrajectoryFitness TrajectoryFitnessQ : trajectoryFitnesses) {
+                int dominates = compare(TrajectoryFitnessP.fitness, TrajectoryFitnessQ.fitness);
+                if (dominates > 0) {
+                    dominatedInstances.get(TrajectoryFitnessP).add(TrajectoryFitnessQ);
+                } else if (dominates < 0) {
+                    dominatingInstances.put(TrajectoryFitnessP, dominatingInstances.get(TrajectoryFitnessP) + 1);
+                }
+            }
+
+            if (dominatingInstances.get(TrajectoryFitnessP) == 0) {
+                // p belongs to the first front
+                TrajectoryFitnessP.rank = 1;
+                if (fronts.isEmpty()) {
+                    ArrayList<TrajectoryFitness> firstDominationFront = new ArrayList<TrajectoryFitness>();
+                    firstDominationFront.add(TrajectoryFitnessP);
+                    fronts.add(firstDominationFront);
+                } else {
+                    List<TrajectoryFitness> firstDominationFront = fronts.get(0);
+                    firstDominationFront.add(TrajectoryFitnessP);
+                }
+            }
+        }
+
+        // create fronts
+        int i = 1;
+        while (fronts.size() == i) {
+            ArrayList<TrajectoryFitness> nextDominationFront = new ArrayList<TrajectoryFitness>();
+            for (TrajectoryFitness TrajectoryFitnessP : fronts.get(i - 1)) {
+                for (TrajectoryFitness TrajectoryFitnessQ : dominatedInstances.get(TrajectoryFitnessP)) {
+                    dominatingInstances.put(TrajectoryFitnessQ, dominatingInstances.get(TrajectoryFitnessQ) - 1);
+                    if (dominatingInstances.get(TrajectoryFitnessQ) == 0) {
+                        TrajectoryFitnessQ.rank = i + 1;
+                        nextDominationFront.add(TrajectoryFitnessQ);
+                    }
+                }
+            }
+            i++;
+            if (!nextDominationFront.isEmpty()) {
+                if (computeCrowdingDistance) {
+                    crowdingDistanceAssignment(nextDominationFront, leveledObjectives);
+                }
+                fronts.add(nextDominationFront);
+            }
+        }
+
+        return fronts;
+    }
+
+    /**
+     * Executes the crowding distance assignment for the specified front.
+     * 
+     * @param front
+     */
+    public static void crowdingDistanceAssignment(List<TrajectoryFitness> front, IObjective[][] leveledObjectives) {
+
+        for (TrajectoryFitness InstanceData : front) {
+            // initialize crowding distance
+            InstanceData.crowdingDistance = 0;
+        }
+
+        for (final IObjective[] objectives : leveledObjectives) {
+            for (final IObjective objective : objectives) {
+
+                final String m = objective.getName();
+                TrajectoryFitness[] sortedFront = front.toArray(new TrajectoryFitness[0]);
+                // sort using m-th objective value
+                Arrays.sort(sortedFront, (o1, o2) -> objective.getComparator().compare(o1.fitness.get(m), o2.fitness.get(m)));
+                // so that boundary points are always selected
+                sortedFront[0].crowdingDistance = Double.POSITIVE_INFINITY;
+                sortedFront[sortedFront.length - 1].crowdingDistance = Double.POSITIVE_INFINITY;
+                // If minimal and maximal fitness value for this objective are
+                // equal, then do not change crowding distance
+                if (sortedFront[0].fitness.get(m) != sortedFront[sortedFront.length - 1].fitness.get(m)) {
+                    for (int i = 1; i < sortedFront.length - 1; i++) {
+                        double newCrowdingDistance = sortedFront[i].crowdingDistance;
+                        newCrowdingDistance += (sortedFront[i + 1].fitness.get(m) - sortedFront[i - 1].fitness.get(m))
+                                / (sortedFront[sortedFront.length - 1].fitness.get(m) - sortedFront[0].fitness.get(m));
+
+                        sortedFront[i].crowdingDistance = newCrowdingDistance;
+                    }
+                }
+            }
+        }
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/TrajectoryFitness.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/TrajectoryFitness.java
new file mode 100644
index 00000000..f783afac
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/TrajectoryFitness.java
@@ -0,0 +1,84 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.eclipse.viatra.dse.designspace.api.TrajectoryInfo;
+
+/**
+ * This class represents a trajectory and its fitness.
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class TrajectoryFitness {
+
+    public Object[] trajectory;
+    public Fitness fitness;
+
+    public int rank;
+    public double crowdingDistance;
+
+    private int hash;
+    
+    public int survive;
+
+    /**
+     * Creates a {@link TrajectoryFitness} with the full trajectory.
+     * @param trajectory The trajectory.
+     * @param fitness The fitness.
+     */
+    public TrajectoryFitness(Object[] trajectory, Fitness fitness) {
+        this.fitness = fitness;
+        this.trajectory = trajectory;
+    }
+
+    /**
+     * Creates a {@link TrajectoryFitness} with the full trajectory.
+     * @param trajectoryInfo The trajectory.
+     * @param fitness The fitness.
+     */
+    public TrajectoryFitness(TrajectoryInfo trajectoryInfo, Fitness fitness) {
+        this.fitness = fitness;
+        List<Object> fullTraj = trajectoryInfo.getTrajectory();
+        trajectory = fullTraj.toArray(new Object[fullTraj.size()]);
+    }
+
+    /**
+     * Creates a {@link TrajectoryFitness} with the given activation id}
+     * @param transition The transition.
+     * @param fitness The fitness.
+     */
+    public TrajectoryFitness(Object transition, Fitness fitness) {
+        this.fitness = fitness;
+        trajectory = new Object[] {transition};
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof TrajectoryFitness) {
+            return Arrays.equals(trajectory, ((TrajectoryFitness) obj).trajectory);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        if (hash == 0 && trajectory.length > 0) {
+            hash = Arrays.hashCode(trajectory);
+        }
+        return hash;
+    }
+
+    @Override
+    public String toString() {
+        return Arrays.toString(trajectory) + fitness.toString();
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/AlwaysSatisfiedDummyHardObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/AlwaysSatisfiedDummyHardObjective.java
new file mode 100644
index 00000000..9898a3b5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/AlwaysSatisfiedDummyHardObjective.java
@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives.impl;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IObjective;
+
+/**
+ * This hard objective is fulfilled in any circumstances. Use it if all states should be regarded as a valid solution.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class AlwaysSatisfiedDummyHardObjective extends BaseObjective {
+
+    private static final String DEFAULT_NAME = "AlwaysSatisfiedDummyHardObjective";
+
+    public AlwaysSatisfiedDummyHardObjective() {
+        super(DEFAULT_NAME);
+    }
+
+    public AlwaysSatisfiedDummyHardObjective(String name) {
+        super(name);
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+        return 0d;
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return true;
+    }
+
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+        return true;
+    }
+
+    @Override
+    public IObjective createNew() {
+        return this;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/BaseObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/BaseObjective.java
new file mode 100644
index 00000000..0a1de875
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/BaseObjective.java
@@ -0,0 +1,150 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives.impl;
+
+import java.util.Comparator;
+import java.util.Objects;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.Comparators;
+import org.eclipse.viatra.dse.objectives.IObjective;
+
+/**
+ * This abstract class implements the basic functionality of an objective ({@link IObjective} namely its name,
+ * comparator, level and fitness hard constraint.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public abstract class BaseObjective implements IObjective {
+
+    protected final String name;
+    protected Comparator<Double> comparator = Comparators.HIGHER_IS_BETTER;
+    protected int level = 0;
+
+    protected double fitnessConstraint;
+    protected boolean isThereFitnessConstraint = false;
+    protected Comparator<Double> fitnessConstraintComparator;
+
+    public BaseObjective(String name) {
+        Objects.requireNonNull(name, "Name of the objective cannot be null.");
+        this.name = name;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public void setComparator(Comparator<Double> comparator) {
+        this.comparator = comparator;
+    }
+
+    @Override
+    public Comparator<Double> getComparator() {
+        return comparator;
+    }
+
+    @Override
+    public void setLevel(int level) {
+        this.level = level;
+    }
+
+    @Override
+    public int getLevel() {
+        return level;
+    }
+
+    public BaseObjective withLevel(int level) {
+        setLevel(level);
+        return this;
+    }
+
+    public BaseObjective withComparator(Comparator<Double> comparator) {
+        setComparator(comparator);
+        return this;
+    }
+
+    /**
+     * Adds a hard constraint on the fitness value. For example, the fitness value must be better than 10 to accept the
+     * current state as a solution.
+     * 
+     * @param fitnessConstraint
+     *            Solutions should be better than this value.
+     * @param fitnessConstraintComparator
+     *            {@link Comparator} to determine if the current state is better than the given value.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public BaseObjective withHardConstraintOnFitness(double fitnessConstraint,
+            Comparator<Double> fitnessConstraintComparator) {
+        this.fitnessConstraint = fitnessConstraint;
+        this.fitnessConstraintComparator = fitnessConstraintComparator;
+        this.isThereFitnessConstraint = true;
+        return this;
+    }
+
+    /**
+     * Adds a hard constraint on the fitness value. For example, the fitness value must be better than 10 to accept the
+     * current state as a solution. The provided comparator will be used.
+     * 
+     * @param fitnessConstraint
+     *            Solutions should be better than this value.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public BaseObjective withHardConstraintOnFitness(double fitnessConstraint) {
+        return withHardConstraintOnFitness(fitnessConstraint, null);
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+        if (fitnessConstraintComparator == null) {
+            fitnessConstraintComparator = comparator;
+        }   
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return isThereFitnessConstraint;
+    }
+    
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+        if (isThereFitnessConstraint) {
+            int compare = fitnessConstraintComparator.compare(fitness, fitnessConstraint);
+            if (compare < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    @Override
+    public int hashCode() {
+        return name.hashCode();
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof BaseObjective) {
+            BaseObjective baseObjective = (BaseObjective) obj;
+            return name.equals(baseObjective.getName());
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/CompositeObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/CompositeObjective.java
new file mode 100644
index 00000000..cc48d22e
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/CompositeObjective.java
@@ -0,0 +1,137 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IObjective;
+import org.eclipse.viatra.query.runtime.matchers.util.Preconditions;
+
+/**
+ * This objective collects a list of other objectives. It returns the weighted sum of the objectives.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class CompositeObjective extends BaseObjective {
+
+    public static final String DEFAULT_NAME = "CompositeObjective";
+    protected List<IObjective> objectives;
+    protected List<Double> weights;
+    protected boolean hardObjective;
+
+    public CompositeObjective(String name, List<IObjective> objectives, List<Double> weights) {
+        super(name);
+        Objects.requireNonNull(objectives, "The list of objectives cannot be null.");
+        Objects.requireNonNull(weights, "The list of weights cannot be null.");
+        Preconditions.checkState(objectives.size() == weights.size(), "The size of the objectives and weights must match.");
+        this.objectives = objectives;
+        this.weights = weights;
+    }
+
+    public CompositeObjective(List<IObjective> objectives, List<Double> weights) {
+        this(DEFAULT_NAME, objectives, weights);
+    }
+
+    public CompositeObjective(String name) {
+        this(name, new ArrayList<IObjective>(), new ArrayList<Double>());
+    }
+
+    public CompositeObjective() {
+        this(DEFAULT_NAME, new ArrayList<IObjective>(), new ArrayList<Double>());
+    }
+
+    /**
+     * Adds a new objective.
+     * 
+     * @param objective
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public CompositeObjective withObjective(IObjective objective) {
+        objectives.add(objective);
+        weights.add(1d);
+        return this;
+    }
+
+    /**
+     * Adds a new objective.
+     * 
+     * @param objective
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public CompositeObjective withObjective(IObjective objective, double weight) {
+        objectives.add(objective);
+        weights.add(weight);
+        return this;
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+
+        double result = 0;
+
+        for (int i = 0; i < objectives.size(); i++) {
+            IObjective objective = objectives.get(i);
+            Double weight = weights.get(i);
+            result += objective.getFitness(context) * weight;
+        }
+        return result;
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+        super.init(context);
+        hardObjective = false;
+        for (IObjective objective : objectives) {
+            objective.init(context);
+            if (objective.isHardObjective()) {
+                hardObjective = true;
+            }
+        }
+    }
+
+    @Override
+    public IObjective createNew() {
+
+        List<IObjective> newObjectives = new ArrayList<IObjective>();
+
+        for (IObjective objective : objectives) {
+            newObjectives.add(objective.createNew());
+        }
+
+        CompositeObjective objective = new CompositeObjective(name, newObjectives, weights);
+        if (isThereFitnessConstraint) {
+            objective.withHardConstraintOnFitness(fitnessConstraint, fitnessConstraintComparator);
+        }
+
+        return objective.withComparator(comparator).withLevel(level);
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return hardObjective;
+    }
+
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+
+        boolean hardObjectiveSatisfied = true;
+
+        for (IObjective objective : objectives) {
+            hardObjectiveSatisfied = objective.satisifiesHardObjective(fitness) ? hardObjectiveSatisfied : false;
+        }
+
+        hardObjectiveSatisfied = super.satisifiesHardObjective(fitness) ? hardObjectiveSatisfied : false;
+
+        return hardObjectiveSatisfied;
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ConstraintsObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ConstraintsObjective.java
new file mode 100644
index 00000000..77d416f5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ConstraintsObjective.java
@@ -0,0 +1,316 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import org.eclipse.viatra.dse.api.DSEException;
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IObjective;
+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.exception.ViatraQueryException;
+
+/**
+ * This objective serves as soft and as hard objective at the same time by defining two lists of VIATRA Query
+ * specifications.
+ * 
+ * As a soft objective, it collects a list of VIATRA Query specifications, which have predefined weights. Then the
+ * fitness value of an arbitrary solution is calculated in the following way:
+ * <p>
+ * <code>fitness = sum( pattern[i].countMatches() * weight[i] )</code>
+ * <p>
+ * As a hard objective it collects a separate list of VIATRA Query specifications. If every one of them has a match the
+ * hard constraint is considered to be fulfilled.
+ * 
+ * @author Andras Szabolcs Nagy
+ * @see IObjective
+ *
+ */
+public class ConstraintsObjective extends BaseObjective {
+
+    public static final String DEFAULT_NAME = "ConstraintsObjective";
+
+    public static class QueryConstraint {
+        public final String name;
+        public final IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> query;
+        public final Double weight;
+        public final ModelQueryType type;
+
+        public QueryConstraint(String name,
+                IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> query, Double weight,
+                ModelQueryType type) {
+            this.name = name;
+            this.query = query;
+            this.weight = weight;
+            this.type = type;
+        }
+
+        public QueryConstraint(String name,
+                IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> query, Double weight) {
+            this(name, query, weight, ModelQueryType.MUST_HAVE_MATCH);
+        }
+
+        public QueryConstraint(String name,
+                IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> query, ModelQueryType type) {
+            this(name, query, 0d, type);
+        }
+    }
+
+    protected List<QueryConstraint> softConstraints;
+    protected List<QueryConstraint> hardConstraints;
+
+    protected List<ViatraQueryMatcher<? extends IPatternMatch>> softMatchers;
+    protected List<ViatraQueryMatcher<? extends IPatternMatch>> hardMatchers;
+    protected List<Integer> softMatches;
+    protected List<Integer> hardMatches;
+
+    public ConstraintsObjective(String name, List<QueryConstraint> softConstraints,
+            List<QueryConstraint> hardConstraints) {
+        super(name);
+        Objects.requireNonNull(softConstraints, "The list of soft constraints cannot be null.");
+        Objects.requireNonNull(hardConstraints, "The list of hard constraints cannot be null.");
+
+        this.softConstraints = softConstraints;
+        this.hardConstraints = hardConstraints;
+    }
+
+    public ConstraintsObjective(String name, List<QueryConstraint> hardConstraints) {
+        this(name, new ArrayList<QueryConstraint>(), hardConstraints);
+    }
+
+    public ConstraintsObjective(List<QueryConstraint> hardConstraints) {
+        this(DEFAULT_NAME, new ArrayList<QueryConstraint>(), hardConstraints);
+    }
+
+    public ConstraintsObjective(String name) {
+        this(name, new ArrayList<QueryConstraint>(), new ArrayList<QueryConstraint>());
+    }
+
+    public ConstraintsObjective() {
+        this(DEFAULT_NAME, new ArrayList<QueryConstraint>(), new ArrayList<QueryConstraint>());
+    }
+
+    /**
+     * Adds a new soft constraint.
+     * 
+     * @param name
+     *            A name for the soft constraint.
+     * @param softConstraint
+     *            A VIATRA Query pattern specification.
+     * @param weight
+     *            The weight of the pattern.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ConstraintsObjective withSoftConstraint(String name,
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> softConstraint, double weight) {
+        softConstraints.add(new QueryConstraint(name, softConstraint, weight));
+        return this;
+    }
+
+    /**
+     * Adds a new soft constraint with the name of the query specification's fully qualified name.
+     * 
+     * @param softConstraint
+     *            A VIATRA Query pattern specification.
+     * @param weight
+     *            The weight of the pattern.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ConstraintsObjective withSoftConstraint(
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> softConstraint, double weight) {
+        return withSoftConstraint(softConstraint.getFullyQualifiedName(), softConstraint, weight);
+    }
+
+    /**
+     * Adds a new hard constraint.
+     * 
+     * @param name
+     *            A name for the hard constraint.
+     * @param softConstraint
+     *            A VIATRA Query pattern specification.
+     * @param type
+     *            {@link ModelQueryType}, which determines whether the constraint should have at least one match or none
+     *            at all.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ConstraintsObjective withHardConstraint(String name,
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hardConstraint,
+            ModelQueryType type) {
+        hardConstraints.add(new QueryConstraint(name, hardConstraint, type));
+        return this;
+    }
+
+    /**
+     * Adds a new hard constraint with the default {@link ModelQueryType#MUST_HAVE_MATCH}.
+     * 
+     * @param name
+     *            A name for the hard constraint.
+     * @param softConstraint
+     *            A VIATRA Query pattern specification.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ConstraintsObjective withHardConstraint(String name,
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hardConstraint) {
+        hardConstraints.add(new QueryConstraint(name, hardConstraint, ModelQueryType.MUST_HAVE_MATCH));
+        return this;
+    }
+
+    /**
+     * Adds a new hard constraint with the name of the query specification's fully qualified name and the default
+     * {@link ModelQueryType#MUST_HAVE_MATCH}.
+     * 
+     * @param softConstraint
+     *            A VIATRA Query pattern specification.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ConstraintsObjective withHardConstraint(
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hardConstraint) {
+        return withHardConstraint(hardConstraint.getFullyQualifiedName(), hardConstraint,
+                ModelQueryType.MUST_HAVE_MATCH);
+    }
+
+    /**
+     * Adds a new hard constraint with the name of the query specification's fully qualified name.
+     * 
+     * @param softConstraint
+     *            A VIATRA Query pattern specification.
+     * @param type
+     *            {@link ModelQueryType}, which determines whether the constraint should have at least one match or none
+     *            at all.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ConstraintsObjective withHardConstraint(
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hardConstraint,
+            ModelQueryType type) {
+        return withHardConstraint(hardConstraint.getFullyQualifiedName(), hardConstraint, type);
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+
+        if (softConstraints.isEmpty()) {
+            return 0d;
+        }
+
+        double result = 0;
+
+        for (int i = 0; i < softConstraints.size(); i++) {
+            int countMatches = softMatchers.get(i).countMatches();
+            result += countMatches * softConstraints.get(i).weight;
+            softMatches.set(i, Integer.valueOf(countMatches));
+        }
+
+        return result;
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+
+        super.init(context);
+
+        softMatches = new ArrayList<Integer>(softConstraints.size());
+        softMatchers = new ArrayList<ViatraQueryMatcher<? extends IPatternMatch>>(softConstraints.size());
+        hardMatches = new ArrayList<Integer>(hardConstraints.size());
+        hardMatchers = new ArrayList<ViatraQueryMatcher<? extends IPatternMatch>>(hardConstraints.size());
+        for (int i = 0; i < softConstraints.size(); i++) {
+            softMatches.add(0);
+        }
+        for (int i = 0; i < hardConstraints.size(); i++) {
+            hardMatches.add(0);
+        }
+
+        try {
+            ViatraQueryEngine queryEngine = context.getQueryEngine();
+
+            for (QueryConstraint qc : softConstraints) {
+                softMatchers.add(qc.query.getMatcher(queryEngine));
+            }
+
+            for (QueryConstraint qc : hardConstraints) {
+                hardMatchers.add(qc.query.getMatcher(queryEngine));
+            }
+
+        } catch (ViatraQueryException e) {
+            throw new DSEException("Couldn't initialize the VIATRA Query matcher, see inner exception", e);
+        }
+    }
+
+    @Override
+    public IObjective createNew() {
+        new ArrayList<Double>(softConstraints.size());
+        ConstraintsObjective result = new ConstraintsObjective(name, softConstraints, hardConstraints);
+        if (isThereFitnessConstraint) {
+            result.withHardConstraintOnFitness(fitnessConstraint, fitnessConstraintComparator);
+        }
+        return result.withComparator(comparator).withLevel(level);
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return !hardConstraints.isEmpty() || super.isHardObjective();
+    }
+
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+
+        boolean result = true;
+
+        for (int i = 0; i < hardConstraints.size(); i++) {
+            ModelQueryType type = hardConstraints.get(i).type;
+            int countMatches = hardMatchers.get(i).countMatches();
+            hardMatches.set(i, Integer.valueOf(countMatches));
+            if ((type.equals(ModelQueryType.MUST_HAVE_MATCH) && countMatches <= 0)
+                    || (type.equals(ModelQueryType.NO_MATCH) && countMatches > 0)) {
+                result = false;
+            }
+        }
+        
+        result = super.satisifiesHardObjective(fitness) ? result : false;
+        
+        return result;
+    }
+
+    public List<QueryConstraint> getSoftConstraints() {
+        return softConstraints;
+    }
+
+    public List<QueryConstraint> getHardConstraints() {
+        return hardConstraints;
+    }
+
+    public String getSoftName(int index) {
+        return softConstraints.get(index).name;
+    }
+
+    public String getHardName(int index) {
+        return hardConstraints.get(index).name;
+    }
+
+    public List<Integer> getSoftMatches() {
+        return softMatches;
+    }
+
+    public List<Integer> getHardMatches() {
+        return hardMatches;
+    }
+
+    public List<String> getSoftNames() {
+        List<String> softNames = new ArrayList<>(softConstraints.size());
+        for (QueryConstraint qc : softConstraints) {
+            softNames.add(qc.name);
+        }
+        return softNames;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/DepthHardObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/DepthHardObjective.java
new file mode 100644
index 00000000..b21da397
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/DepthHardObjective.java
@@ -0,0 +1,89 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives.impl;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IObjective;
+
+/**
+ * This hard objective is fulfilled if the trajectory is in the specified interval (inclusive).
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class DepthHardObjective extends BaseObjective {
+
+    private static final String DEFAULT_NAME = "DepthHardObjective";
+    protected int minDepth;
+    protected int maxDepth;
+    private ThreadContext context;
+
+    public DepthHardObjective() {
+        this(DEFAULT_NAME, 0, Integer.MAX_VALUE);
+    }
+
+    public DepthHardObjective(String name) {
+        this(name, 0, Integer.MAX_VALUE);
+    }
+
+    public DepthHardObjective(int minDepth) {
+        this(DEFAULT_NAME, minDepth, Integer.MAX_VALUE);
+    }
+
+    public DepthHardObjective(String name, int minDepth) {
+        this(name, minDepth, Integer.MAX_VALUE);
+    }
+
+    public DepthHardObjective(int minDepth, int maxDepth) {
+        this(DEFAULT_NAME, minDepth, maxDepth);
+    }
+    
+    public DepthHardObjective(String name, int minDepth, int maxDepth) {
+        super(name);
+        this.minDepth = minDepth;
+        this.maxDepth = maxDepth;
+    }
+
+    public DepthHardObjective withMinDepth(int minDepth) {
+        this.minDepth = minDepth;
+        return this;
+    }
+
+    public DepthHardObjective withMaxDepth(int maxDepth) {
+        this.maxDepth = maxDepth;
+        return this;
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+        super.init(context);
+        this.context = context;
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+        return 0d;
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return true;
+    }
+
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+        return minDepth <= context.getDepth() && context.getDepth() <= maxDepth;
+    }
+
+    @Override
+    public IObjective createNew() {
+        return new DepthHardObjective(name, minDepth, maxDepth);
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ModelQueriesGlobalConstraint.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ModelQueriesGlobalConstraint.java
new file mode 100644
index 00000000..7616b4a2
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ModelQueriesGlobalConstraint.java
@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import org.eclipse.viatra.dse.api.DSEException;
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IGlobalConstraint;
+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.exception.ViatraQueryException;
+
+/**
+ * This global constraint collects a list of VIATRA Query pattern and checks if any of them has a match on along a trajectory.
+ * If any of the patterns has a match then it is unsatisfied and the exploration should backtrack.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class ModelQueriesGlobalConstraint implements IGlobalConstraint {
+
+    public static final String GLOBAL_CONSTRAINT = "GlobalConstraint";
+    protected String name;
+    protected List<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> constraints;
+    protected List<ViatraQueryMatcher<? extends IPatternMatch>> matchers = new ArrayList<ViatraQueryMatcher<? extends IPatternMatch>>();
+    protected ModelQueryType type = ModelQueryType.NO_MATCH;
+
+    public ModelQueriesGlobalConstraint(String name,
+            List<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> constraints) {
+        Objects.requireNonNull(name, "Name of the global constraint cannot be null.");
+        Objects.requireNonNull(constraints, "The list of constraints cannot be null.");
+
+        this.name = name;
+        this.constraints = constraints;
+    }
+
+    public ModelQueriesGlobalConstraint(
+            List<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> constraints) {
+        this(GLOBAL_CONSTRAINT, constraints);
+    }
+
+    public ModelQueriesGlobalConstraint(String name) {
+        this(name, new ArrayList<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>());
+    }
+
+    public ModelQueriesGlobalConstraint() {
+        this(GLOBAL_CONSTRAINT,
+                new ArrayList<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>());
+    }
+
+    /**
+     * Adds a new VIATRA Query pattern.
+     * 
+     * @param constraint
+     *            A VIATRA Query pattern.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public ModelQueriesGlobalConstraint withConstraint(
+            IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> constraint) {
+        constraints.add(constraint);
+        return this;
+    }
+
+    public ModelQueriesGlobalConstraint withType(ModelQueryType type) {
+        this.type = type;
+        return this;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public boolean checkGlobalConstraint(ThreadContext context) {
+        for (ViatraQueryMatcher<? extends IPatternMatch> matcher : matchers) {
+            if ((type.equals(ModelQueryType.NO_MATCH) && matcher.countMatches() > 0)
+                    || (type.equals(ModelQueryType.MUST_HAVE_MATCH) && matcher.countMatches() == 0)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+        try {
+            ViatraQueryEngine queryEngine = context.getQueryEngine();
+
+            for (IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> querySpecification : constraints) {
+                ViatraQueryMatcher<? extends IPatternMatch> matcher = querySpecification.getMatcher(queryEngine);
+                matchers.add(matcher);
+            }
+
+        } catch (ViatraQueryException e) {
+        throw new DSEException("Couldn't get the VIATRA Query matcher, see inner exception", e);
+        }
+    }
+
+    @Override
+    public IGlobalConstraint createNew() {
+        return new ModelQueriesGlobalConstraint(name, constraints);
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ModelQueryType.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ModelQueryType.java
new file mode 100644
index 00000000..76390352
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/ModelQueryType.java
@@ -0,0 +1,14 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives.impl;
+
+public enum ModelQueryType {
+    MUST_HAVE_MATCH,
+    NO_MATCH
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/NeverSatisfiedDummyHardObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/NeverSatisfiedDummyHardObjective.java
new file mode 100644
index 00000000..27cf139c
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/NeverSatisfiedDummyHardObjective.java
@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives.impl;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IObjective;
+
+/**
+ * This hard objective is never fulfilled. Use it if all states should be regarded as an invalid solution.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class NeverSatisfiedDummyHardObjective extends BaseObjective {
+
+    private static final String DEFAULT_NAME = "NeverSatisfiedDummyHardObjective";
+
+    public NeverSatisfiedDummyHardObjective() {
+        super(DEFAULT_NAME);
+    }
+
+    public NeverSatisfiedDummyHardObjective(String name) {
+        super(name);
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+        return 0d;
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return true;
+    }
+
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+        return false;
+    }
+
+    @Override
+    public IObjective createNew() {
+        return this;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/NoRuleActivationsHardObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/NoRuleActivationsHardObjective.java
new file mode 100644
index 00000000..756d94ec
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/NoRuleActivationsHardObjective.java
@@ -0,0 +1,59 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives.impl;
+
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.objectives.IObjective;
+
+/**
+ * This hard objective is satisfied if there are no rule activations from the current state (returning 1 in this case).
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class NoRuleActivationsHardObjective extends BaseObjective {
+
+    protected static final String DEFAULT_NAME = "NoMoreActivationHardObjective";
+    private ThreadContext context;
+
+    public NoRuleActivationsHardObjective(String name) {
+        super(name);
+    }
+
+    public NoRuleActivationsHardObjective() {
+        this(DEFAULT_NAME);
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+        return 0d;
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+        super.init(context);
+        this.context = context;
+    }
+
+    @Override
+    public IObjective createNew() {
+        return new NoRuleActivationsHardObjective(name);
+    }
+
+    @Override
+    public boolean isHardObjective() {
+        return true;
+    }
+
+    @Override
+    public boolean satisifiesHardObjective(Double fitness) {
+        return context.getConflictSet().getNextActivations().isEmpty();
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/TrajectoryCostSoftObjective.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/TrajectoryCostSoftObjective.java
new file mode 100644
index 00000000..25ff45ae
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/objectives/impl/TrajectoryCostSoftObjective.java
@@ -0,0 +1,148 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.objectives.impl;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+
+import org.eclipse.viatra.dse.base.DesignSpaceManager;
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.designspace.api.TrajectoryInfo;
+import org.eclipse.viatra.dse.objectives.ActivationFitnessProcessor;
+import org.eclipse.viatra.dse.objectives.Comparators;
+import org.eclipse.viatra.dse.objectives.IObjective;
+import org.eclipse.viatra.query.runtime.matchers.util.Preconditions;
+import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule;
+
+/**
+ * This soft objective calculates a fitness value based on the length of the trajectory. Costs to the rules can be
+ * assigned.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class TrajectoryCostSoftObjective extends BaseObjective {
+
+    public static final String DEFAULT_NAME = "TrajectoryCostObjective";
+    protected Map<BatchTransformationRule<?, ?>, Double> fixCosts;
+    protected Map<BatchTransformationRule<?, ?>, ActivationFitnessProcessor> activationCostProcessors;
+    protected double trajectoryLengthWeight = 0.0;
+    protected boolean calculateTrajectoryLengthWeight;
+
+    public TrajectoryCostSoftObjective(String name) {
+        super(name);
+        comparator = Comparators.LOWER_IS_BETTER;
+    }
+
+    public TrajectoryCostSoftObjective() {
+        this(DEFAULT_NAME);
+    }
+
+    /**
+     * Sets the cost of a rule.
+     * 
+     * @param rule
+     * @param cost
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public TrajectoryCostSoftObjective withRuleCost(BatchTransformationRule<?, ?> rule, double cost) {
+        Objects.requireNonNull(rule);
+        if (fixCosts == null) {
+            fixCosts = new HashMap<BatchTransformationRule<?, ?>, Double>();
+        }
+        Preconditions.checkArgument(!fixCosts.containsKey(rule));
+        fixCosts.put(rule, cost);
+        return this;
+    }
+
+    /**
+     * Sets an activation processor for a rule.
+     * 
+     * @param rule
+     * @param activationCostProcessor
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public TrajectoryCostSoftObjective withActivationCost(BatchTransformationRule<?, ?> rule,
+            ActivationFitnessProcessor activationCostProcessor) {
+        Objects.requireNonNull(rule);
+        Objects.requireNonNull(activationCostProcessor);
+        if (activationCostProcessors == null) {
+            activationCostProcessors = new HashMap<BatchTransformationRule<?, ?>, ActivationFitnessProcessor>();
+        }
+        Preconditions.checkArgument(!activationCostProcessors.containsKey(rule));
+        activationCostProcessors.put(rule, activationCostProcessor);
+        return this;
+    }
+
+    /**
+     * The length of the trajectory multiplied with given parameter will be added to the fitness value.
+     * 
+     * @param trajectoryLengthWeight
+     *            The weight of a transformation rule application.
+     * @return The actual instance to enable builder pattern like usage.
+     */
+    public TrajectoryCostSoftObjective withTrajectoryLengthWeight(double trajectoryLengthWeight) {
+        this.trajectoryLengthWeight = trajectoryLengthWeight;
+        this.calculateTrajectoryLengthWeight = true;
+        return this;
+    }
+
+    @Override
+    public Double getFitness(ThreadContext context) {
+
+        DesignSpaceManager dsm = context.getDesignSpaceManager();
+        TrajectoryInfo trajectoryInfo = dsm.getTrajectoryInfo();
+        List<Object> trajectory = trajectoryInfo.getTrajectory();
+        List<BatchTransformationRule<?, ?>> rules = trajectoryInfo.getRules();
+
+        double result = 0;
+
+        for (int i = 0; i < trajectory.size(); i++) {
+            BatchTransformationRule<?, ?> rule = rules.get(i);
+
+            Double cost = fixCosts.get(rule);
+            if (cost != null) {
+                result += cost;
+            }
+
+            Map<String, Double> costs = trajectoryInfo.getMeasuredCosts().get(i);
+            if (costs != null) {
+                cost = costs.get(name);
+                if (cost != null) {
+                    result += cost;
+                }
+            }
+        }
+
+        if (calculateTrajectoryLengthWeight) {
+            result += trajectory.size() * trajectoryLengthWeight;
+        }
+
+        return result;
+    }
+
+    @Override
+    public void init(ThreadContext context) {
+        super.init(context);
+        DesignSpaceManager dsm = context.getDesignSpaceManager();
+        if (activationCostProcessors != null) {
+            for (Entry<BatchTransformationRule<?, ?>, ActivationFitnessProcessor> entry : activationCostProcessors.entrySet()) {
+                dsm.registerActivationCostProcessor(name, entry.getKey(), entry.getValue());
+            }
+        }
+    }
+
+    @Override
+    public IObjective createNew() {
+        return this;
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/ISolutionFoundHandler.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/ISolutionFoundHandler.java
new file mode 100644
index 00000000..8d74e856
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/ISolutionFoundHandler.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.solutionstore;
+
+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.solutionstore.SolutionStore.ISolutionSaver;
+
+/**
+ * Contains callback methods which are called when a solution is found by the exploration {@link IStrategy}.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public interface ISolutionFoundHandler {
+
+    /**
+     * Called when a solution is saved by the {@link ISolutionSaver}. Later, this solution can be omitted from the final
+     * set of solutions.
+     * 
+     * @param context
+     * @param trajectory
+     */
+    void solutionFound(ThreadContext context, SolutionTrajectory trajectory);
+
+    /**
+     * Called when the exploration found a solution but it was not saved because of certain conditions.
+     * 
+     * @param context
+     * @param trajectory
+     */
+    void solutionTriedToSave(ThreadContext context, SolutionTrajectory trajectory);
+}
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/ISolutionNameProvider.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/ISolutionNameProvider.java
new file mode 100644
index 00000000..36e6b5b7
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/ISolutionNameProvider.java
@@ -0,0 +1,18 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.solutionstore;
+
+/**
+ * Provides file name when a model is searialzed.
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public interface ISolutionNameProvider {
+    String getName();
+}
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/IdBasedSolutionNameProvider.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/IdBasedSolutionNameProvider.java
new file mode 100644
index 00000000..43460015
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/IdBasedSolutionNameProvider.java
@@ -0,0 +1,37 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.solutionstore;
+
+/**
+ * Provides file name with a String <code>[prefix][id].[extension]</code> pattern.
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class IdBasedSolutionNameProvider implements ISolutionNameProvider {
+
+    private int id = 1;
+    private String prefix;
+    private String extension;
+
+    public IdBasedSolutionNameProvider(String prefix, String extension) {
+        this.extension = extension;
+        this.prefix = prefix;
+
+    }
+
+    @Override
+    public String getName() {
+        StringBuilder sb = new StringBuilder(prefix);
+        sb.append(id++);
+        sb.append('.');
+        sb.append(extension);
+        return sb.toString();
+    }
+
+}
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/LogSolutionHandler.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/LogSolutionHandler.java
new file mode 100644
index 00000000..118f0c75
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/LogSolutionHandler.java
@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.solutionstore;
+
+import org.apache.log4j.Logger;
+import org.eclipse.viatra.dse.api.SolutionTrajectory;
+import org.eclipse.viatra.dse.base.ThreadContext;
+
+public class LogSolutionHandler implements ISolutionFoundHandler {
+
+    Logger logger = Logger.getLogger(LogSolutionHandler.class);
+
+    @Override
+    public void solutionFound(ThreadContext context, SolutionTrajectory trajectory) {
+        logger.info("Solution registered: " + trajectory.toPrettyString());
+    }
+
+    @Override
+    public void solutionTriedToSave(ThreadContext context, SolutionTrajectory trajectory) {
+        logger.debug("Not good enough solution: " + trajectory.toPrettyString());
+    }
+}
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/ModelSaverSolutionFoundHandler.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/ModelSaverSolutionFoundHandler.java
new file mode 100644
index 00000000..bbbe60de
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/ModelSaverSolutionFoundHandler.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.solutionstore;
+
+import java.util.HashSet;
+
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.viatra.dse.api.SolutionTrajectory;
+import org.eclipse.viatra.dse.base.ThreadContext;
+import org.eclipse.viatra.dse.util.EMFHelper;
+
+public class ModelSaverSolutionFoundHandler implements ISolutionFoundHandler {
+
+    private HashSet<Object> savedSolutions = new HashSet<Object>();
+    private ISolutionNameProvider solutionNameProvider;
+
+    public ModelSaverSolutionFoundHandler() {
+        solutionNameProvider = new IdBasedSolutionNameProvider("solution", "xmi");
+    }
+
+    public ModelSaverSolutionFoundHandler(String extension) {
+        solutionNameProvider = new IdBasedSolutionNameProvider("solution", extension);
+    }
+
+    public ModelSaverSolutionFoundHandler(String prefix, String extension) {
+        solutionNameProvider = new IdBasedSolutionNameProvider(prefix, extension);
+    }
+
+    public ModelSaverSolutionFoundHandler(ISolutionNameProvider solutionNameProvider) {
+        this.solutionNameProvider = solutionNameProvider;
+    }
+
+    @Override
+    public void solutionTriedToSave(ThreadContext context, SolutionTrajectory trajectory) {
+    }
+
+    @Override
+    public void solutionFound(ThreadContext context, SolutionTrajectory trajectory) {
+        Object stateCode = trajectory.getSolution().getStateCode();
+
+        if (savedSolutions.contains(stateCode)) {
+            return;
+        }
+
+        savedSolutions.add(stateCode);
+        Notifier clonedModel = EMFHelper.clone(context.getModel());
+        EMFHelper.saveModel(clonedModel, solutionNameProvider.getName());
+    }
+}
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/SolutionStore.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/SolutionStore.java
new file mode 100644
index 00000000..578ae277
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/solutionstore/SolutionStore.java
@@ -0,0 +1,311 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.solutionstore;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.log4j.Level;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.notify.Notifier;
+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.DesignSpaceManager;
+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.statecode.IStateCoderFactory;
+import org.eclipse.viatra.dse.util.EMFHelper;
+import org.eclipse.viatra.query.runtime.exception.ViatraQueryException;
+
+/**
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class SolutionStore {
+
+    public interface ISolutionSaver {
+        void setSolutionsCollection(Map<Object, Solution> solutions);
+        boolean saveSolution(ThreadContext context, Object id, SolutionTrajectory solutionTrajectory);
+    }
+
+    public interface IEnoughSolutions extends ISolutionFoundHandler {
+        boolean enoughSolutions();
+    }
+
+    public static class ANumberOfEnoughSolutions implements IEnoughSolutions {
+
+        private final AtomicInteger foundSolutions;
+        private final AtomicBoolean foundEnoughSolutions;
+
+        public ANumberOfEnoughSolutions(int number) {
+            foundSolutions = new AtomicInteger(number);
+            foundEnoughSolutions = new AtomicBoolean(false);
+        }
+
+        @Override
+        public boolean enoughSolutions() {
+            return foundEnoughSolutions.get();
+        }
+
+        @Override
+        public void solutionFound(ThreadContext context, SolutionTrajectory trajectory) {
+            int solutionsToFind = foundSolutions.decrementAndGet();
+            if (solutionsToFind == 0) {
+                foundEnoughSolutions.set(true);
+            }
+        }
+
+        @Override
+        public void solutionTriedToSave(ThreadContext context, SolutionTrajectory trajectory) {
+        }
+    }
+
+    public static class SimpleSolutionSaver implements ISolutionSaver {
+
+        private Map<Object, Solution> solutions;
+
+        @Override
+        public void setSolutionsCollection(Map<Object, Solution> solutions) {
+            this.solutions = solutions;
+        }
+
+        @Override
+        public boolean saveSolution(ThreadContext context, Object id, SolutionTrajectory solutionTrajectory) {
+            Solution solution = solutions.get(id);
+            if (solution != null) {
+                if (solution.getTrajectories().contains(solutionTrajectory)) {
+                    return false;
+                } else {
+                    solution.addTrajectory(solutionTrajectory);
+                    solutionTrajectory.setSolution(solution);
+                }
+            } else {
+                solution = new Solution(id, solutionTrajectory);
+                solutions.put(id, solution);
+                solutionTrajectory.setSolution(solution);
+            }
+            return true;
+        }
+    }
+
+    public static class BestSolutionSaver implements ISolutionSaver {
+
+        private Map<Object, Solution> solutions;
+        private Map<SolutionTrajectory, Fitness> trajectories = new HashMap<>();
+
+        @Override
+        public void setSolutionsCollection(Map<Object, Solution> solutions) {
+            this.solutions = solutions;
+        }
+
+        @Override
+        public boolean saveSolution(ThreadContext context, Object id, SolutionTrajectory solutionTrajectory) {
+
+            Fitness lastFitness = context.getLastFitness();
+            ObjectiveComparatorHelper comparatorHelper = context.getObjectiveComparatorHelper();
+
+            List<SolutionTrajectory> dominatedTrajectories = new ArrayList<>();
+
+            for (Entry<SolutionTrajectory, Fitness> entry : trajectories.entrySet()) {
+                int isLastFitnessBetter = comparatorHelper.compare(lastFitness, entry.getValue());
+                if (isLastFitnessBetter < 0) {
+                    return false;
+                }
+                if (isLastFitnessBetter > 0) {
+                    dominatedTrajectories.add(entry.getKey());
+                }
+            }
+
+            boolean solutionSaved = false;
+
+            Solution solution = solutions.get(id);
+            if (solution != null) {
+                if (!solution.getTrajectories().contains(solutionTrajectory)) {
+                    solution.addTrajectory(solutionTrajectory);
+                    solutionTrajectory.setSolution(solution);
+                    solutionSaved = true;
+                    trajectories.put(solutionTrajectory, lastFitness);
+                }
+            } else {
+                solution = new Solution(id, solutionTrajectory);
+                solutions.put(id, solution);
+                solutionTrajectory.setSolution(solution);
+                solutionSaved = true;
+                trajectories.put(solutionTrajectory, lastFitness);
+            }
+
+            for (SolutionTrajectory st : dominatedTrajectories) {
+                trajectories.remove(st);
+                Solution s = st.getSolution();
+                if (!s.getTrajectories().remove(st)) {
+                    throw new DSEException("Should not happen.");
+                }
+                if (s.getTrajectories().isEmpty()) {
+                    Object stateCode = s.getStateCode();
+                    solutions.remove(stateCode);
+                }
+            }
+
+            return solutionSaved;
+        }
+
+    }
+
+    protected boolean acceptOnlyGoalSolutions = true;
+    protected final Map<Object, Solution> solutions = new HashMap<Object, Solution>();
+    protected ISolutionSaver solutionSaver = new SimpleSolutionSaver();
+    protected List<ISolutionFoundHandler> solutionFoundHandlers = new ArrayList<ISolutionFoundHandler>(1);
+
+    protected final IEnoughSolutions enoughSolutions;
+
+    public SolutionStore() {
+        this(new IEnoughSolutions() {
+            @Override
+            public void solutionFound(ThreadContext context, SolutionTrajectory trajectory) {
+            }
+
+            @Override
+            public boolean enoughSolutions() {
+                return false;
+            }
+
+            @Override
+            public void solutionTriedToSave(ThreadContext context, SolutionTrajectory trajectory) {
+            }
+        });
+    }
+
+    public SolutionStore(int numOfSolutionsToFind) {
+        this(new ANumberOfEnoughSolutions(numOfSolutionsToFind));
+    }
+
+    public SolutionStore(IEnoughSolutions enoughSolutionsImpl) {
+        enoughSolutions = enoughSolutionsImpl;
+    }
+
+    public synchronized void newSolution(ThreadContext context) {
+        solutionSaver.setSolutionsCollection(solutions);
+        Fitness fitness = context.getLastFitness();
+        DesignSpaceManager dsm = context.getDesignSpaceManager();
+        Object id = dsm.getCurrentState();
+        IStateCoderFactory stateCoderFactory = context.getGlobalContext().getStateCoderFactory();
+        SolutionTrajectory solutionTrajectory = dsm.getTrajectoryInfo().createSolutionTrajectory(stateCoderFactory, context.getDesignSpaceManager());
+        solutionTrajectory.setFitness(fitness);
+
+        if (acceptOnlyGoalSolutions && !fitness.isSatisifiesHardObjectives()) {
+            unsavedSolutionCallbacks(context, solutionTrajectory);
+            return;
+        }
+
+        boolean solutionSaved = solutionSaver.saveSolution(context, id, solutionTrajectory);
+
+        if (solutionSaved) {
+            enoughSolutions.solutionFound(context, solutionTrajectory);
+
+            savedSolutionCallbacks(context, solutionTrajectory);
+
+            if (enoughSolutions.enoughSolutions()) {
+                context.getGlobalContext().stopAllThreads();
+            }
+        } else {
+            unsavedSolutionCallbacks(context, solutionTrajectory);
+        }
+    }
+
+    private void unsavedSolutionCallbacks(ThreadContext context, SolutionTrajectory solutionTrajectory) {
+        for (ISolutionFoundHandler handler : solutionFoundHandlers) {
+            handler.solutionTriedToSave(context, solutionTrajectory);
+        }
+    }
+
+    private void savedSolutionCallbacks(ThreadContext context, SolutionTrajectory solutionTrajectory) {
+        for (ISolutionFoundHandler handler : solutionFoundHandlers) {
+            handler.solutionFound(context, solutionTrajectory);
+        }
+    }
+
+    public synchronized Collection<Solution> getSolutions() {
+        return solutions.values();
+    }
+
+    public synchronized void registerSolutionFoundHandler(ISolutionFoundHandler handler) {
+        if (solutionFoundHandlers == null) {
+            solutionFoundHandlers = new ArrayList<ISolutionFoundHandler>(1);
+        }
+        solutionFoundHandlers.add(handler);
+    }
+
+    public SolutionStore logSolutionsWhenFound() {
+        registerSolutionFoundHandler(new LogSolutionHandler());
+        Logger.getLogger(LogSolutionHandler.class).setLevel(Level.INFO);
+        return this;
+    }
+
+    public SolutionStore saveModelWhenFound() {
+        registerSolutionFoundHandler(new ModelSaverSolutionFoundHandler());
+        return this;
+    }
+
+    public SolutionStore saveModelWhenFound(String extension) {
+        registerSolutionFoundHandler(new ModelSaverSolutionFoundHandler(extension));
+        return this;
+    }
+
+    public SolutionStore saveModelWhenFound(String prefix, String extension) {
+        registerSolutionFoundHandler(new ModelSaverSolutionFoundHandler(prefix, extension));
+        return this;
+    }
+
+    public SolutionStore saveModelWhenFound(ISolutionNameProvider solutionNameProvider) {
+        registerSolutionFoundHandler(new ModelSaverSolutionFoundHandler(solutionNameProvider));
+        return this;
+    }
+
+    public SolutionStore acceptGoalSolutionsOnly() {
+        acceptOnlyGoalSolutions = true;
+        return this;
+    }
+
+    public SolutionStore acceptAnySolutions() {
+        acceptOnlyGoalSolutions = false;
+        return this;
+    }
+
+    public SolutionStore withSolutionSaver(ISolutionSaver solutionSaver) {
+        this.solutionSaver = solutionSaver;
+        return this;
+    }
+
+    public SolutionStore storeBestSolutionsOnly() {
+        this.solutionSaver = new BestSolutionSaver();
+        return this;
+    }
+
+    public void saveModels(Notifier model, ISolutionNameProvider solutionNameProvider) {
+        try {
+            for (Solution solution : solutions.values()) {
+                SolutionTrajectory trajectory = solution.getArbitraryTrajectory();
+                trajectory.doTransformationUndoable(model);
+                EMFHelper.saveModel(model, solutionNameProvider.getName());
+                trajectory.undoTransformation();
+            }
+        } catch (ViatraQueryException e) {
+            Logger.getLogger(SolutionStore.class).error("Exception happened during model saving.", e);
+        }
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecode/IStateCoder.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecode/IStateCoder.java
new file mode 100644
index 00000000..f163f1a5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecode/IStateCoder.java
@@ -0,0 +1,82 @@
+/*******************************************************************************

+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro

+ * This program and the accompanying materials are made available under the

+ * terms of the Eclipse Public License v. 2.0 which is available at

+ * http://www.eclipse.org/legal/epl-v20.html.

+ * 

+ * SPDX-License-Identifier: EPL-2.0

+ *******************************************************************************/

+package org.eclipse.viatra.dse.statecode;

+

+import org.eclipse.emf.common.notify.Notifier;

+import org.eclipse.viatra.query.runtime.api.IPatternMatch;

+

+/**

+ * <p>

+ * To be able to efficiently explore a design space, a state that has been explored before through an other trajectory

+ * needs to be recognized and ignored accordingly.

+ * </p>

+ * 

+ * <p>

+ * This is done by generating a pseudo-unique value (object) that is only depended on the relevant parts of the model's

+ * internal state, that is, the values of two states can only be equal if the states themselves can be considered equal.

+ * </p>

+ * 

+ * <p>

+ * The processing engine however assumes, that any two states that share this pseudo-unique value has the same

+ * characteristics, meaning they have the same amount and type of outgoing transitions available, and firing the

+ * appropriate transitions from both states also result in states that share their pseudo-unique identifier. If this

+ * condition is not satisfied, the exploration process's result will be non-deterministic, and in consequence, solutions

+ * can be lost.

+ * </p>

+ * 

+ * <p>

+ * In addition to providing pseudo-unique identifiers to model states, the state coder must provide pseud-unique

+ * identifiers to the outgoing transitions as well, but they only need to be unique on the scope of the particular

+ * state, not globally. Global addressing thus can be achieved by considering the pseudo-unique identifier of the state

+ * and the pseudo-unique identifier of the transition together if needed.

+ * </p>

+ * 

+ * <p>

+ * Both identifiers can be arbitrary objects, and equality is checked by calling {@link Object#equals(Object)} on the

+ * two identifiers.

+ * </p>

+ * 

+ * <p>

+ * For any particular implementation an {@link IStateCoderFactory} implementation must also be supplied that handles the

+ * creation of {@link IStateCoder} instances.

+ * </p>

+ * 

+ * <p>

+ * Usually it is unnecessary to represent everything from the model in a state code, only the parts which are modified

+ * by the transformation rules.

+ * </p>

+ * 

+ * @author Miklos Foldenyi, Andras Szabolcs Nagy

+ * 

+ */

+public interface IStateCoder {

+

+    /**

+     * Initializes the state coder on the given model.

+     * 

+     * @param notifier

+     */

+    void init(Notifier notifier);

+

+    /**

+     * Returns a pseudo-unique identifier that describes the underlying model's current internal state.

+     * 

+     * @return an arbitrary {@link Object} that can be used as the identifier.

+     */

+    Object createStateCode();

+

+    /**

+     * Returns a pseudo-unique identifier that describes the given {@link IPatternMatch} in the context of the

+     * underlying model's current internal state.

+     * 

+     * @return an arbitrary {@link Object} that can be used as the identifier in the given state.

+     */

+    Object createActivationCode(IPatternMatch match);

+

+}

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecode/IStateCoderFactory.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecode/IStateCoderFactory.java
new file mode 100644
index 00000000..cf8bdf8d
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecode/IStateCoderFactory.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.statecode;
+
+/**
+ * Interface for a factory class that creates instances of {@link IStateCoder} objects. This is required because state
+ * coders have to be created on-demand if the design space exploration process decides that a new thread is to be
+ * spawned. Since each thread requires it's own working model instance and a state coder is linked to the underlying
+ * model, a new {@link IStateCoder} needs to be created per processing thread.
+ * 
+ * @author Miklos Foldenyi, Andras Szabolcs Nagy
+ * 
+ */
+public interface IStateCoderFactory {
+
+    /**
+     * Creates a new {@link IStateCoder} instance specific to this {@link IStateCoderFactory}.
+     * 
+     * @return the new {@link IStateCoder} instance specific to this working model.
+     */
+    IStateCoder createStateCoder();
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/IObjectsProvider.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/IObjectsProvider.java
new file mode 100644
index 00000000..afcba7b6
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/IObjectsProvider.java
@@ -0,0 +1,45 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.statecoding;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+
+/**
+ * Implementation of this interface is responsible to provide {@link EObject}s of a given {@link EClass} for
+ * {@link TheStateCoder}
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public interface IObjectsProvider {
+
+    /**
+     * Initialize the {@link IObjectsProvider} on a given model and {@link StatecodingDependencyGraph}.
+     * 
+     * @param notifier
+     *            The root of the model.
+     * @param statecodingDependencyGraph
+     *            The state coding dependency graph.
+     */
+    void init(Notifier notifier, StatecodingDependencyGraph statecodingDependencyGraph);
+
+    /**
+     * Returns the instances of an {@link EClass} in a model.
+     * 
+     * @param eClass
+     *            The class of the objects.
+     * @return The collection of the instances.
+     */
+    Collection<EObject> getEObjects(EClass eClass);
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/IObjectsProviderFactory.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/IObjectsProviderFactory.java
new file mode 100644
index 00000000..931eb1a2
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/IObjectsProviderFactory.java
@@ -0,0 +1,25 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.statecoding;
+
+/**
+ * Interface for creating {@link IObjectsProvider} instances.
+ * 
+ * @author Andras Szabolcs Nagy
+ */
+public interface IObjectsProviderFactory {
+
+    /**
+     * Creates an {@link IObjectsProvider} implementation.
+     * 
+     * @return The newly created {@link IObjectsProvider}.
+     */
+    IObjectsProvider createObjectsProvider();
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/IncrementalObjectProvider.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/IncrementalObjectProvider.java
new file mode 100644
index 00000000..e38d45d3
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/IncrementalObjectProvider.java
@@ -0,0 +1,60 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.statecoding;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.viatra.dse.api.DSEException;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.base.api.IndexingLevel;
+import org.eclipse.viatra.query.runtime.base.api.NavigationHelper;
+import org.eclipse.viatra.query.runtime.emf.EMFScope;
+import org.eclipse.viatra.query.runtime.exception.ViatraQueryException;
+
+public class IncrementalObjectProvider implements IObjectsProvider {
+
+    private Logger logger = Logger.getLogger(getClass());
+    private NavigationHelper baseIndex;
+
+    @Override
+    public void init(Notifier notifier, StatecodingDependencyGraph statecodingDependencyGraph) {
+
+        try {
+            EMFScope scope = new EMFScope(notifier);
+            ViatraQueryEngine queryEngine = ViatraQueryEngine.on(scope);
+
+            Set<EClass> classes = new HashSet<EClass>();
+//          Set<EReference> references = new HashSet<EReference>();
+            for (StatecodingNode node : statecodingDependencyGraph.getNodes()) {
+                classes.add(node.getClazz());
+//              for (StatecodingDependency dependency : node.getStatecodingDependencies()) {
+//                  // TODO inverse reference
+//                  references.add(dependency.eReference);
+//              }
+            }
+            baseIndex = EMFScope.extractUnderlyingEMFIndex(queryEngine);
+            baseIndex.registerEClasses(classes, IndexingLevel.FULL);
+        } catch (ViatraQueryException e) {
+            logger.error("Failed to initialize VIATRA Query engine on the given notifier", e);
+            throw new DSEException("Failed to initialize VIATRA Query engine on the given notifier");
+        }
+    }
+
+    @Override
+    public Collection<EObject> getEObjects(EClass eClass) {
+        return baseIndex.getAllInstances(eClass);
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/IncrementalObjectProviderFactory.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/IncrementalObjectProviderFactory.java
new file mode 100644
index 00000000..97011436
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/IncrementalObjectProviderFactory.java
@@ -0,0 +1,18 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.statecoding;
+
+public class IncrementalObjectProviderFactory implements IObjectsProviderFactory {
+
+    @Override
+    public IncrementalObjectProvider createObjectsProvider() {
+        return new IncrementalObjectProvider();
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingDependency.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingDependency.java
new file mode 100644
index 00000000..67b1982d
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingDependency.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.statecoding;
+
+import org.eclipse.emf.ecore.EReference;
+
+public class StatecodingDependency {
+
+    protected EReference eReference;
+    protected StatecodingNode node;
+    protected boolean isContained;
+    protected StatecodingDependencyType type;
+
+    public StatecodingDependency(EReference eReference, StatecodingNode node, boolean isContained,
+            StatecodingDependencyType type) {
+        super();
+        this.eReference = eReference;
+        this.node = node;
+        this.isContained = isContained;
+        this.type = type;
+    }
+
+    public StatecodingDependency(EReference eReference, StatecodingNode node) {
+        this(eReference, node, false, StatecodingDependencyType.NORMAL);
+    }
+
+}
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingDependencyGraph.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingDependencyGraph.java
new file mode 100644
index 00000000..6f7255a3
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingDependencyGraph.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.statecoding;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.emf.ecore.EClass;
+
+public class StatecodingDependencyGraph {
+
+    private List<StatecodingNode> nodes = new ArrayList<StatecodingNode>();
+
+    public StatecodingNode createNode(EClass clazz) {
+        StatecodingNode node = new StatecodingNode(clazz);
+        node.setGraph(this);
+        addNode(node);
+        return node;
+    }
+
+    public void addNode(StatecodingNode node) {
+        nodes.add(node);
+    }
+
+    public StatecodingNode getNodeByClass(EClass eClass) {
+        for (StatecodingNode node : nodes) {
+            if (node.getClazz().equals(eClass)) {
+                return node;
+            }
+        }
+        return null;
+    }
+
+    public List<StatecodingNode> getNodes() {
+        return nodes;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingDependencyType.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingDependencyType.java
new file mode 100644
index 00000000..bdd4677d
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingDependencyType.java
@@ -0,0 +1,15 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.statecoding;
+
+public enum StatecodingDependencyType {
+
+    NORMAL,
+    INVERSE
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingNode.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingNode.java
new file mode 100644
index 00000000..91fc28cf
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingNode.java
@@ -0,0 +1,100 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.statecoding;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EReference;
+
+public class StatecodingNode {
+
+    private StatecodingDependencyGraph graph;
+
+    private final EClass clazz;
+    private Set<EAttribute> attributes = new TreeSet<EAttribute>(Comparator.comparing(EAttribute::getName));
+    private List<StatecodingDependency> dependencies = new ArrayList<StatecodingDependency>();
+    private boolean stateCodeIsId = false;
+    private StatecodingNodeType statecodingNodeType = StatecodingNodeType.CREATE_AND_DELETE;
+
+    public StatecodingNode(EClass clazz) {
+        this.clazz = clazz;
+    }
+
+    public StatecodingNode withAttribute(EAttribute attribute) {
+        attributes.add(attribute);
+        return this;
+    }
+
+    public StatecodingNode withType(StatecodingNodeType type) {
+        statecodingNodeType = type;
+        return this;
+    }
+
+    public StatecodingNode withUniqueness() {
+        stateCodeIsId = true;
+        return this;
+    }
+
+    public StatecodingNode withDependency(EReference reference, StatecodingNode node) {
+        dependencies.add(new StatecodingDependency(reference, node));
+        return this;
+    }
+
+    public StatecodingNode withInverseDependency(EReference reference, StatecodingNode node) {
+        dependencies.add(new StatecodingDependency(reference, node, false, StatecodingDependencyType.INVERSE));
+        return this;
+    }
+
+    public void addDependency(StatecodingDependency statecodingDependency) {
+        dependencies.add(statecodingDependency);
+    }
+
+    public EClass getClazz() {
+        return clazz;
+    }
+
+    public boolean isStateCodeIsId() {
+        return stateCodeIsId;
+    }
+
+    public void setStateCodeIsId(boolean stateCodeIsId) {
+        this.stateCodeIsId = stateCodeIsId;
+    }
+
+    public StatecodingNodeType getStatecodingNodeType() {
+        return statecodingNodeType;
+    }
+
+    public void setStatecodingNodeType(StatecodingNodeType statecodingNodeType) {
+        this.statecodingNodeType = statecodingNodeType;
+    }
+
+    public Set<EAttribute> getAttributes() {
+        return attributes;
+    }
+
+    public List<StatecodingDependency> getStatecodingDependencies() {
+        return dependencies;
+    }
+
+    public StatecodingDependencyGraph getGraph() {
+        return graph;
+    }
+
+    public void setGraph(StatecodingDependencyGraph graph) {
+        this.graph = graph;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingNodeType.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingNodeType.java
new file mode 100644
index 00000000..c902a7a6
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/StatecodingNodeType.java
@@ -0,0 +1,17 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.statecoding;
+
+public enum StatecodingNodeType {
+
+    FIXED,
+    ONLY_CREATE,
+    ONLY_DELETE,
+    CREATE_AND_DELETE
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/TheStateCoder.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/TheStateCoder.java
new file mode 100644
index 00000000..4601ff08
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/TheStateCoder.java
@@ -0,0 +1,215 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.statecoding;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.viatra.dse.api.DSEException;
+import org.eclipse.viatra.dse.statecode.IStateCoder;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+
+public class TheStateCoder implements IStateCoder {
+
+    private StatecodingDependencyGraph sdg;
+    private IObjectsProvider objectProvider;
+
+    public TheStateCoder(StatecodingDependencyGraph sdg, IObjectsProvider objectProvider) {
+        this.sdg = sdg;
+        this.objectProvider = objectProvider;
+    }
+
+    @Override
+    public void init(Notifier notifier) {
+        // TODO checks
+        // TODO node sorting based on traversal - in factory
+
+        // this.notifier = notifier;
+        // try {
+        // EMFScope scope = new EMFScope(notifier);
+        // queryEngine = ViatraQueryEngine.on(scope);
+        // } catch (ViatraQueryException e1) {
+        // logger.error("Failed to initialize VIATRA Query engine on the given notifier", e1);
+        // throw new DSEException("Failed to initialize VIATRA Query engine on the given notifier");
+        // }
+
+        objectProvider.init(notifier, sdg);
+    }
+
+    @Override
+    public String createStateCode() {
+
+        StringBuilder sb = new StringBuilder();
+
+        // TODO sort
+        for (StatecodingNode node : sdg.getNodes()) {
+            sb.append(node.getClazz().getName());
+            sb.append(':');
+            sb.append(addStateCode(node));
+            sb.append('|');
+        }
+        sb.deleteCharAt(sb.length() - 1);
+
+        return sb.toString();
+
+    }
+
+    @Override
+    public Object createActivationCode(IPatternMatch match) {
+        // TODO root object
+        // TODO parameterless?
+
+        int i = 0;
+        StringBuilder sb = new StringBuilder();
+        Object object;
+        do {
+            object = match.get(i++);
+            if (object != null) {
+                if (object instanceof EObject) {
+                    EObject eObject = (EObject) object;
+                    sb.append(addStateCode(sdg.getNodeByClass(eObject.eClass()), eObject));
+                } else {
+                    // TODO toString or not to toString
+                }
+            }
+        } while (object != null);
+
+        return sb.toString();
+    }
+
+    public String addStateCode(StatecodingNode node, EObject eObject) {
+        StringBuilder sb = new StringBuilder();
+
+        Set<EAttribute> attributes = node.getAttributes();
+        if (!attributes.isEmpty()) {
+            for (EAttribute eAttribute : attributes) {
+                // attributes are sorted
+                // TODO handle collection
+                sb.append(eObject.eGet(eAttribute));
+                sb.append(';');
+            }
+            sb.deleteCharAt(sb.length() - 1);
+        }
+
+        List<StatecodingDependency> dependencies = node.getStatecodingDependencies();
+        int dependenciesSize = dependencies.size();
+        if (dependenciesSize > 0) {
+            String[] codeParts = new String[dependenciesSize];
+            int i = 0;
+            for (StatecodingDependency dependency : dependencies) {
+                String code = addStateCodeFromDependency(dependency, eObject);
+                codeParts[i++] = code;
+            }
+            Arrays.sort(codeParts);
+
+            sb.append("(");
+            sb.append(codeParts[0]);
+            for (i = 1; i < codeParts.length; i++) {
+                sb.append(';');
+                sb.append(codeParts[i]);
+            }
+            sb.append(")");
+        }
+        return sb.toString();
+    }
+
+    public String addStateCode(StatecodingNode node) {
+        Collection<EObject> eObjects = objectProvider.getEObjects(node.getClazz());
+        int size = eObjects.size();
+
+        if (size > 0) {
+            String[] codeParts = new String[size];
+            int i = 0;
+            for (EObject eObject : eObjects) {
+                String code = addStateCode(node, eObject);
+                codeParts[i++] = code;
+            }
+            Arrays.sort(codeParts);
+
+            StringBuilder sb = new StringBuilder();
+            sb.append(codeParts[0]);
+            for (i = 1; i < codeParts.length; i++) {
+                sb.append(';');
+                sb.append(codeParts[i]);
+            }
+            return sb.toString();
+        }
+
+        return "";
+    }
+
+    public String addStateCodeFromDependency(StatecodingDependency sd, EObject eObject) {
+
+        if (sd.type.equals(StatecodingDependencyType.NORMAL)) {
+
+            Object eReferred = eObject.eGet(sd.eReference);
+            if (eReferred == null) {
+                return "";
+            } else if (eReferred instanceof EList<?>) {
+                EList<?> refferedList = (EList<?>) eReferred;
+                // TODO test
+                if (!refferedList.isEmpty()) {
+
+                    String[] codeParts = new String[refferedList.size()];
+                    int i = 0;
+                    for (Object referredEObject : refferedList) {
+                        String code = addStateCode(sd.node, (EObject) referredEObject);
+                        codeParts[i++] = code;
+                    }
+                    Arrays.sort(codeParts);
+
+                    StringBuilder sb = new StringBuilder();
+                    sb.append('[');
+                    sb.append(codeParts[0]);
+                    for (i = 1; i < codeParts.length; i++) {
+                        sb.append(';');
+                        sb.append(codeParts[i]);
+                    }
+                    sb.append(']');
+                    return sb.toString();
+
+                }
+            } else if (eReferred instanceof EObject) {
+                return addStateCode(sd.node, (EObject) eReferred);
+            } else {
+                throw new DSEException("The EObject " + eObject.toString() + " does not have a feature "
+                        + eReferred.toString() + ".");
+            }
+
+        } else {
+            for (EObject dependentEObject : objectProvider.getEObjects(sd.node.getClazz())) {
+                Object eReferred = dependentEObject.eGet(sd.eReference);
+                if (eReferred == null) {
+                    continue;
+                } else if (eReferred instanceof EList<?>) {
+                    // TODO this is slow, use VIATRA Query
+                    for (Object referredEObject : ((EList<?>) eReferred)) {
+                        if (referredEObject.equals(eObject)) {
+                            return addStateCode(sd.node, (EObject) dependentEObject);
+                        }
+                    }
+                } else if (eReferred.equals(eObject)) {
+                    // Probably never happens?
+                    return addStateCode(sd.node, (EObject) dependentEObject);
+                } else {
+                    throw new DSEException("The EObject " + eObject.toString() + " does not have a feature "
+                            + eReferred.toString() + ".");
+                }
+            }
+        }
+
+        return "";
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/TheStateCoderFactory.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/TheStateCoderFactory.java
new file mode 100644
index 00000000..eeb6e48f
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/TheStateCoderFactory.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.statecoding;
+
+import org.eclipse.viatra.dse.statecode.IStateCoder;
+import org.eclipse.viatra.dse.statecode.IStateCoderFactory;
+
+public class TheStateCoderFactory implements IStateCoderFactory {
+
+    private StatecodingDependencyGraph sdg;
+    private IObjectsProviderFactory objectProviderFactory;
+
+    public TheStateCoderFactory(StatecodingDependencyGraph sdg) {
+        this(sdg, new IncrementalObjectProviderFactory());
+    }
+
+    public TheStateCoderFactory(StatecodingDependencyGraph sdg, IObjectsProviderFactory objectProviderFactory) {
+        this.sdg = sdg;
+        this.objectProviderFactory = objectProviderFactory;
+
+        // TODO cyclic dependency? - exception
+        
+        // TODO make plan for traversal
+        
+        // TODO If the type is FIXED and all dependency is FIXED then do not create state code for it (them)
+        // This is not true :( e.g. matchmaking - they are fixed, but the references must be encoded
+    }
+
+    @Override
+    public IStateCoder createStateCoder() {
+        return new TheStateCoder(sdg, objectProviderFactory.createObjectsProvider());
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/simple/SimpleStateCoder.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/simple/SimpleStateCoder.java
new file mode 100644
index 00000000..0f0759ae
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/simple/SimpleStateCoder.java
@@ -0,0 +1,250 @@
+/*******************************************************************************

+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro

+ * This program and the accompanying materials are made available under the

+ * terms of the Eclipse Public License v. 2.0 which is available at

+ * http://www.eclipse.org/legal/epl-v20.html.

+ * 

+ * SPDX-License-Identifier: EPL-2.0

+ *******************************************************************************/

+package org.eclipse.viatra.dse.statecoding.simple;

+

+import java.util.Arrays;

+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 org.eclipse.emf.common.notify.Notifier;

+import org.eclipse.emf.ecore.EAttribute;

+import org.eclipse.emf.ecore.EClass;

+import org.eclipse.emf.ecore.EObject;

+import org.eclipse.emf.ecore.EReference;

+import org.eclipse.emf.ecore.EStructuralFeature;

+import org.eclipse.emf.ecore.EStructuralFeature.Setting;

+import org.eclipse.viatra.dse.api.DSEException;

+import org.eclipse.viatra.dse.statecode.IStateCoder;

+import org.eclipse.viatra.dse.util.EMFHelper.MetaModelElements;

+import org.eclipse.viatra.dse.util.ValueComparableEObjectStringMap;

+import org.eclipse.viatra.query.runtime.api.IPatternMatch;

+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;

+import org.eclipse.viatra.query.runtime.base.api.FeatureListener;

+import org.eclipse.viatra.query.runtime.base.api.IndexingLevel;

+import org.eclipse.viatra.query.runtime.base.api.InstanceListener;

+import org.eclipse.viatra.query.runtime.base.api.NavigationHelper;

+import org.eclipse.viatra.query.runtime.emf.EMFBaseIndexWrapper;

+import org.eclipse.viatra.query.runtime.emf.EMFScope;

+import org.eclipse.viatra.query.runtime.exception.ViatraQueryException;

+

+/**

+ * 

+ * @author Andras Szabolcs Nagy

+ *

+ */

+public class SimpleStateCoder implements IStateCoder {

+

+    private Set<EClass> classes;

+    private Set<EStructuralFeature> features;

+    private NavigationHelper navigationHelper;

+

+    private Map<EClass, Map<EObject, String>> objectCodes;

+    private int maxDepth;

+

+    private Set<EObject> changedOrNewEObjects = new HashSet<EObject>();

+    private Set<EObject> deletedClasses = new HashSet<EObject>();

+

+    public SimpleStateCoder(MetaModelElements metaModelElements) {

+        this.maxDepth = 1;

+

+        classes = metaModelElements.classes;

+        features = new HashSet<EStructuralFeature>(metaModelElements.attributes);

+        features.addAll(metaModelElements.references);

+    }

+

+    @Override

+    public void init(Notifier notifier) {

+        try {

+            EMFScope scope = new EMFScope(notifier);

+            ViatraQueryEngine queryEngine = ViatraQueryEngine.on(scope);

+            EMFBaseIndexWrapper baseIndex = (EMFBaseIndexWrapper) queryEngine.getBaseIndex();

+            navigationHelper = baseIndex.getNavigationHelper();

+            navigationHelper.registerObservedTypes(classes, null, features, IndexingLevel.FULL);

+        } catch (ViatraQueryException e) {

+            throw new DSEException(e);

+        }

+

+        objectCodes = new HashMap<EClass, Map<EObject, String>>();

+        for (EClass eClass : classes) {

+            Map<EObject, String> codes = new ValueComparableEObjectStringMap();

+

+            objectCodes.put(eClass, codes);

+

+            for (EObject eObject : navigationHelper.getDirectInstances(eClass)) {

+                codes.put(eObject, createObjectCodeWithDepth(eObject, maxDepth));

+            }

+        }

+

+        navigationHelper.addFeatureListener(features, new FeatureListener() {

+

+            @Override

+            public void featureInserted(EObject host, EStructuralFeature feature, Object value) {

+                changedOrNewEObjects.add(host);

+            }

+

+            @Override

+            public void featureDeleted(EObject host, EStructuralFeature feature, Object value) {

+                changedOrNewEObjects.add(host);

+                if (value instanceof EObject) {

+                    changedOrNewEObjects.add((EObject) value);

+                }

+            }

+        });

+

+        navigationHelper.addInstanceListener(classes, new InstanceListener() {

+

+            @Override

+            public void instanceInserted(EClass clazz, EObject instance) {

+                changedOrNewEObjects.add(instance);

+            }

+

+            @Override

+            public void instanceDeleted(EClass clazz, EObject instance) {

+                deletedClasses.add(instance);

+            }

+        });

+    }

+

+    private String createObjectCodeWithDepth(EObject eObject, int depth) {

+

+        StringBuilder sb = new StringBuilder();

+

+        Collection<EAttribute> attributes = eObject.eClass().getEAllAttributes();

+        for (EAttribute eAttribute : attributes) {

+            Object value = eObject.eGet(eAttribute);

+            sb.append(value);

+            sb.append(',');

+        }

+        if (!attributes.isEmpty()) {

+            sb.deleteCharAt(sb.length() - 1);

+        }

+        if (depth > 0) {

+            sb.append('-');

+            Collection<EReference> eReferences = eObject.eClass().getEAllReferences();

+            for (EReference eReference : eReferences) {

+                Object value = eObject.eGet(eReference);

+                if (value == null) {

+                    sb.append("null,");

+                } else if (value instanceof EObject) {

+                    sb.append(createObjectCodeWithDepth((EObject) value, depth - 1));

+                    sb.append(',');

+                } else {

+                    List<EObject> referencedEObjects = (List<EObject>) value;

+                    if (!referencedEObjects.isEmpty()) {

+

+                        String[] codes = new String[referencedEObjects.size()];

+                        int index = 0;

+                        for (EObject referencedEObject : referencedEObjects) {

+                            codes[index++] = createObjectCodeWithDepth(referencedEObject, depth - 1);

+                        }

+                        Arrays.sort(codes);

+                        sb.append('(');

+                        for (String code : codes) {

+                            sb.append(code);

+                        }

+                        sb.append("),");

+                    }

+                }

+            }

+            sb.deleteCharAt(sb.length() - 1);

+        }

+        return sb.toString();

+    }

+

+    @Override

+    public Object createStateCode() {

+

+        refreshObjectCodes();

+

+        StringBuilder sb = new StringBuilder();

+

+        for (EClass eClass : classes) {

+

+            Set<EObject> instances = navigationHelper.getDirectInstances(eClass);

+

+            if (!instances.isEmpty()) {

+

+                sb.append(eClass.getName());

+                sb.append(':');

+

+                String[] codesToSort = new String[instances.size()];

+                int index = 0;

+                Map<EObject, String> codes = objectCodes.get(eClass);

+                for (EObject eObject : instances) {

+                    codesToSort[index++] = codes.get(eObject);

+                }

+                Arrays.sort(codesToSort);

+                for (String string : codesToSort) {

+                    sb.append(string);

+                    sb.append(';');

+                }

+                sb.deleteCharAt(sb.length() - 1);

+                sb.append('|');

+            }

+        }

+        if (sb.length() != 0) {

+            sb.deleteCharAt(sb.length() - 1);

+        }

+        return sb.toString();

+    }

+

+    private void refreshObjectCodes() {

+        for (EObject eObject : deletedClasses) {

+            EClass eClass = eObject.eClass();

+            objectCodes.get(eClass).remove(eObject);

+        }

+        deletedClasses.clear();

+

+        Set<EObject> objectsToRecode = new HashSet<EObject>();

+        for (EObject eObject : changedOrNewEObjects) {

+            objectsToRecode.add(eObject);

+            for (Setting setting : navigationHelper.getInverseReferences(eObject)) {

+                objectsToRecode.add(setting.getEObject());

+            }

+        }

+

+        for (EObject eObject : objectsToRecode) {

+            EClass eClass = eObject.eClass();

+            objectCodes.get(eClass).put(eObject, createObjectCodeWithDepth(eObject, maxDepth));

+        }

+        changedOrNewEObjects.clear();

+    }

+

+    @Override

+    public Object createActivationCode(IPatternMatch match) {

+

+        StringBuilder sb = new StringBuilder();

+        String[] tokens = match.specification().getFullyQualifiedName().split("\\.");

+        sb.append(tokens[tokens.length - 1]);

+        sb.append(':');

+        Object param;

+        for (int i = 0; (param = match.get(i)) != null; i++) {

+            EObject eObject = (EObject) param;

+

+            Collection<EAttribute> attributes = eObject.eClass().getEAllAttributes();

+            for (EAttribute eAttribute : attributes) {

+                Object value = eObject.eGet(eAttribute);

+                sb.append(value);

+                sb.append(',');

+            }

+            if (!attributes.isEmpty()) {

+                sb.deleteCharAt(sb.length() - 1);

+            }

+

+            sb.append('|');

+        }

+        sb.deleteCharAt(sb.length() - 1);

+        return sb.toString().intern();

+    }

+

+}

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/simple/SimpleStateCoderFactory.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/simple/SimpleStateCoderFactory.java
new file mode 100644
index 00000000..d776e8a8
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/statecoding/simple/SimpleStateCoderFactory.java
@@ -0,0 +1,38 @@
+/*******************************************************************************

+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro

+ * This program and the accompanying materials are made available under the

+ * terms of the Eclipse Public License v. 2.0 which is available at

+ * http://www.eclipse.org/legal/epl-v20.html.

+ * 

+ * SPDX-License-Identifier: EPL-2.0

+ *******************************************************************************/

+package org.eclipse.viatra.dse.statecoding.simple;

+

+import java.util.Collection;

+import java.util.HashSet;

+

+import org.eclipse.emf.ecore.EPackage;

+import org.eclipse.viatra.dse.statecode.IStateCoder;

+import org.eclipse.viatra.dse.statecode.IStateCoderFactory;

+import org.eclipse.viatra.dse.util.EMFHelper;

+import org.eclipse.viatra.dse.util.EMFHelper.MetaModelElements;

+

+/**

+ * 

+ * @author Andras Szabolcs Nagy

+ *

+ */

+public class SimpleStateCoderFactory implements IStateCoderFactory {

+

+    private MetaModelElements metaModelElements;

+

+    public SimpleStateCoderFactory(Collection<EPackage> metaModelPackages) {

+        metaModelElements = EMFHelper.getAllMetaModelElements(new HashSet<EPackage>(metaModelPackages));

+    }

+

+    @Override

+    public IStateCoder createStateCoder() {

+        return new SimpleStateCoder(metaModelElements);

+    }

+

+}

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/util/EMFHelper.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/util/EMFHelper.java
new file mode 100644
index 00000000..14b3acfb
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/util/EMFHelper.java
@@ -0,0 +1,424 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.util;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.command.BasicCommandStack;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.ENamedElement;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+import org.eclipse.emf.ecore.util.EcoreUtil.Copier;
+import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
+import org.eclipse.emf.edit.command.AddCommand;
+import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
+import org.eclipse.emf.edit.domain.EditingDomain;
+import org.eclipse.viatra.query.runtime.matchers.util.Preconditions;
+
+/**
+ * This class contains static helper methods.
+ * @author Andras Szabolcs Nagy
+ */
+public final class EMFHelper {
+
+    private static final Logger logger = Logger.getLogger(EMFHelper.class);
+
+    private EMFHelper() {
+    }
+
+    public static class EmfHelperException extends RuntimeException {
+        private static final long serialVersionUID = 7635796550669616626L;
+        
+        public EmfHelperException(String string) {
+            super(string);
+        }
+        public EmfHelperException(String string, Throwable e) {
+            super(string, e);
+        }
+    }
+
+    /**
+     * Gets the {@link EditingDomain} of either an {@link EObject}, {@link Resource} or {@link ResourceSet}.
+     * @param notifier The {@link Notifier}.
+     * @return The EditingDomain.
+     */
+    public static EditingDomain getEditingDomain(Notifier notifier) {
+        Objects.requireNonNull(notifier);
+        if (notifier instanceof EObject) {
+            EObject eObject = (EObject) notifier;
+            return AdapterFactoryEditingDomain.getEditingDomainFor(eObject);
+        } else if (notifier instanceof Resource) {
+            Resource resource = (Resource) notifier;
+            EList<EObject> contents = resource.getContents();
+            if (contents.isEmpty()) {
+                return null;
+            }
+            return AdapterFactoryEditingDomain.getEditingDomainFor(contents.get(0));
+        } else if (notifier instanceof ResourceSet) {
+            ResourceSet resourceSet = (ResourceSet) notifier;
+            if (resourceSet.getResources().isEmpty()) {
+                return null;
+            }
+            return getEditingDomain(resourceSet.getResources().get(0));
+        }
+        
+        return null;
+    }
+    
+    /**
+     * Creates (or gets if already exists) an {@link EditingDomain} over the given {@link Notifier},
+     * either an {@link EObject}, {@link Resource} or {@link ResourceSet}.
+     * @param notifier The {@link Notifier}.
+     * @return The EditingDomain.
+     */
+    public static EditingDomain createEditingDomain(Notifier notifier) {
+        
+        EditingDomain domain = getEditingDomain(notifier);
+        if (domain != null) {
+            return domain;
+        }
+        
+        registerExtensionForXmiSerializer("dummyext");
+        
+        if (notifier instanceof EObject) {
+            EObject eObject = (EObject) notifier;
+
+            domain = new AdapterFactoryEditingDomain(null, new BasicCommandStack());
+            Resource resource = domain.getResourceSet().createResource(URI.createFileURI("dummy.dummyext"));
+            domain.getCommandStack().execute(new AddCommand(domain, resource.getContents(), eObject));
+            
+            return domain;
+            
+        } else if (notifier instanceof Resource) {
+            Resource resource = (Resource) notifier;
+            
+            ResourceSet resourceSet = resource.getResourceSet();
+            if (resourceSet != null) {
+                return new AdapterFactoryEditingDomain(null, new BasicCommandStack(), resourceSet);
+            } else {
+                domain = new AdapterFactoryEditingDomain(null, new BasicCommandStack(), (ResourceSet) null);
+                resourceSet = domain.getResourceSet();
+                domain.getCommandStack().execute(new AddCommand(domain, resourceSet.getResources(), resource));
+                return domain;
+            }
+            
+        } else if (notifier instanceof ResourceSet) {
+            return new AdapterFactoryEditingDomain(null, new BasicCommandStack(), (ResourceSet) notifier);
+        } else {
+            throw new EmfHelperException("Not supported argument type.");
+        }
+    }
+
+    /**
+     * Saves the EMF model (EObject or Resource) into the given file. An {@link XMIResourceFactoryImpl} will be
+     * registered if not already.
+     * 
+     * Doesn't throw exception but logs an error if the save was unsuccessful.
+     * 
+     * @param model Can be an {@link EObject} or a {@link Resource}.
+     * @param fileName
+     */
+    public static void saveModel(Notifier model, String fileName) {
+
+        Objects.requireNonNull(model);
+        Preconditions.checkArgument(fileName != null && !fileName.isEmpty(), "File name is null or empty.");
+
+        int extensionIndex = fileName.lastIndexOf('.');
+
+        Preconditions.checkState(extensionIndex > -1 && extensionIndex != fileName.length() - 1, "Bad file extension.");
+
+        String ext = fileName.substring(extensionIndex + 1);
+
+        registerExtensionForXmiSerializer(ext);
+
+        URI uri = URI.createFileURI(fileName);
+        Resource resource;
+
+        if (model instanceof ResourceSet) {
+            throw new EmfHelperException("Unsupported type: ResourceSet");
+        } else if (model instanceof Resource) {
+            resource = (Resource) model;
+        } else if (model instanceof EObject) {
+            EObject root = (EObject) model;
+            ResourceSet resSet = new ResourceSetImpl();
+            resource = resSet.createResource(uri);
+            resource.getContents().add(root);
+        } else {
+            throw new EmfHelperException("Unkown type: " + model.getClass());
+        }
+
+        resource.setURI(uri);
+        saveResource(resource);
+    }
+
+    private static void saveResource(Resource resource) {
+        try {
+            resource.save(Collections.emptyMap());
+        } catch (IOException e) {
+            logger.error(e);
+        }
+    }
+
+    /**
+     * Loads a model as a {@link Resource}. In headless mode, don't forget to call XYZPackage.eINSTANCE.
+     */
+    public static Resource loadModel(String fileName) throws IOException {
+        Preconditions.checkArgument(fileName != null && !fileName.isEmpty(), "File name is null or empty.");
+        int extensionIndex = fileName.lastIndexOf('.');
+        Preconditions.checkState(extensionIndex > -1 && extensionIndex != fileName.length() - 1, "Bad file extension.");
+
+        String ext = fileName.substring(extensionIndex + 1);
+        registerExtensionForXmiSerializer(ext);
+
+        ResourceSetImpl rSet = new ResourceSetImpl();
+        URI fileUri = URI.createFileURI(fileName);
+        Resource resource = rSet.createResource(fileUri);
+
+        resource.load(null);
+        return resource;
+    }
+
+    /**
+     * Retrieves the root EObject from a Resource or ResourceSet.
+     * <ul>
+     * <li>Returns null if there is no content.</li>
+     * <li>Returns the notifier itself if it is an EObject.</li>
+     * <li>Logs a warn if there are multiple roots.</li>
+     * </ul>
+     * 
+     * @param notifier
+     * @return The root EObject or null.
+     */
+    public static EObject getRootEObject(Notifier notifier) {
+        if (notifier instanceof EObject) {
+            return (EObject) notifier;
+        } else if (notifier instanceof Resource) {
+            Resource resource = (Resource) notifier;
+            List<EObject> contents = resource.getContents();
+            if (contents.size() > 1) {
+                logger.warn("Resource has more than one root.");
+            }
+            if (contents.isEmpty()) {
+                return null;
+            } else {
+                return contents.get(0);
+            }
+        } else if (notifier instanceof ResourceSet) {
+            ResourceSet resourceSet = (ResourceSet) notifier;
+            List<Resource> resources = resourceSet.getResources();
+            if (resources.size() > 1) {
+                logger.warn("ResourceSet has more than one resources.");
+            }
+            if (resources.isEmpty()) {
+                return null;
+            } else {
+                return getRootEObject(resources.get(0));
+            }
+        } else {
+            throw new EmfHelperException("Unkown type: " + notifier.getClass());
+        }
+    }
+
+    /**
+     * Registers an {@link XMIResourceFactoryImpl} for the given extension.
+     * @param ext The extension as a String.
+     */
+    public static void registerExtensionForXmiSerializer(String ext) {
+        Resource.Factory.Registry reg = Resource.Factory.Registry.INSTANCE;
+        Map<String, Object> m = reg.getExtensionToFactoryMap();
+        m.computeIfAbsent(ext, e -> new XMIResourceFactoryImpl());
+    }
+
+    /**
+     * Clones the given model. Either an {@link EObject}, {@link Resource} or {@link ResourceSet}.
+     * @param notifier The root container of the model.
+     * @return The cloned model.
+     */
+    public static Notifier clone(Notifier notifier) {
+        Copier copier = new Copier();
+        Notifier clonedModel = clone(notifier, copier, null);
+        copier.copyReferences();
+        return clonedModel;
+    }
+
+    private static Notifier clone(Notifier notifier, Copier copier, ResourceSet resourceSetToCloneTo) {
+        Objects.requireNonNull(copier);
+        
+        if (notifier instanceof EObject) {
+            EObject eObject = (EObject) notifier;
+            return copier.copy(eObject);
+        } else if (notifier instanceof Resource) {
+            Resource resource = (Resource) notifier;
+            ResourceSet rSetTemp = resourceSetToCloneTo;
+            if (resourceSetToCloneTo == null) {
+                rSetTemp = new ResourceSetImpl();
+            }
+            Resource clonedResource = rSetTemp.createResource(URI.createFileURI("dummy.dummyext"));
+            
+            for (EObject eObject : resource.getContents()) {
+                EObject clonedEObject = copier.copy(eObject);
+                clonedResource.getContents().add(clonedEObject);
+            }
+            
+            return clonedResource;
+        } else if (notifier instanceof ResourceSet) {
+            ResourceSet resourceSet = (ResourceSet) notifier;
+            ResourceSetImpl clonedResourceSet = new ResourceSetImpl();
+            
+            for (Resource resource : resourceSet.getResources()) {
+                clone(resource, copier, clonedResourceSet);
+            }
+            
+            return clonedResourceSet;
+        } else {
+            throw new EmfHelperException("Not supported argument type.");
+        }
+    }
+
+    public static class ENamedElementComparator implements Comparator<ENamedElement> {
+        @Override
+        public int compare(ENamedElement eClass1, ENamedElement eClass2) {
+            return eClass1.getName().compareTo(eClass2.getName());
+        }
+    }
+
+    /**
+     * This class is used to store
+     * <ul>
+     * <li>{@link EClass}es,</li>
+     * <li>{@link EAttribute}s,</li>
+     * <li>{@link EReference}s,</li>
+     * <li>EAttributes by EClasses,</li>
+     * <li>EReferences by EClasses</li>
+     * </ul>
+     * for a given set of {@link EPackage}s.
+     *
+     */
+    public static class MetaModelElements {
+        public Set<EPackage> metaModelPackages;
+        public Set<EClass> classes;
+        public Set<EAttribute> attributes;
+        public Set<EReference> references;
+        public Map<EClass, Set<EAttribute>> attributesOfClass;
+        public Map<EClass, Set<EReference>> referencesOfClass;
+    }
+
+    /**
+     * Traverses the full metamodel on the given {@link EPackage}s and returns all the classes, attributes and
+     * references it contains.
+     * 
+     * @param metaModelPackages
+     *            The set of {@link EPackage}s.
+     * @return A {@link MetaModelElements} instance containing the metamodel elements.
+     */
+    public static MetaModelElements getAllMetaModelElements(Set<EPackage> metaModelPackages) {
+        return getMetaModelElements(metaModelPackages, true, true, true);
+    }
+
+    /**
+     * Return a {@link MetaModelElements} instance populated with its {@link MetaModelElements#classes}.
+     * 
+     * @param metaModelPackages
+     *            The set of {@link EPackage}s.
+     * @return AA {@link MetaModelElements} instance.
+     */
+    public static MetaModelElements getClasses(Set<EPackage> metaModelPackages) {
+        return getMetaModelElements(metaModelPackages, true, false, false);
+    }
+
+    /**
+     * Return a {@link MetaModelElements} instance populated with its {@link MetaModelElements#references} and
+     * {@link MetaModelElements#referencesOfClass}.
+     * 
+     * @param metaModelPackages
+     *            The set of {@link EPackage}s.
+     * @return AA {@link MetaModelElements} instance.
+     */
+    public static MetaModelElements getReferences(Set<EPackage> metaModelPackages) {
+        return getMetaModelElements(metaModelPackages, false, true, false);
+    }
+
+    /**
+     * Return a {@link MetaModelElements} instance populated with its {@link MetaModelElements#attributes} and
+     * {@link MetaModelElements#attributesOfClass}.
+     * 
+     * @param metaModelPackages
+     *            The set of {@link EPackage}s.
+     * @return AA {@link MetaModelElements} instance.
+     */
+    public static MetaModelElements getAttrbiutes(Set<EPackage> metaModelPackages) {
+        return getMetaModelElements(metaModelPackages, false, false, true);
+    }
+
+    private static MetaModelElements getMetaModelElements(Set<EPackage> metaModelPackages, boolean getClasses,
+            boolean getReferences, boolean getAttrbiutes) {
+
+        Comparator<ENamedElement> comparator = new ENamedElementComparator();
+
+        MetaModelElements result = new MetaModelElements();
+        result.metaModelPackages = metaModelPackages;
+        if (getClasses) {
+            result.classes = new TreeSet<EClass>(comparator);
+        }
+        if (getReferences) {
+            result.references = new HashSet<EReference>();
+            result.referencesOfClass = new HashMap<EClass, Set<EReference>>();
+        }
+        if (getAttrbiutes) {
+            result.attributes = new HashSet<EAttribute>();
+            result.attributesOfClass = new HashMap<EClass, Set<EAttribute>>();
+        }
+        for (EPackage ePackage : metaModelPackages) {
+            for (EClassifier eClassifier : ePackage.getEClassifiers()) {
+                if (eClassifier instanceof EClass) {
+                    EClass eClass = ((EClass) eClassifier);
+                    if (getClasses) {
+                        result.classes.add(eClass);
+                    }
+                    if (getReferences) {
+                        result.referencesOfClass.put(eClass, new TreeSet<EReference>(comparator));
+                        for (EReference eReference : eClass.getEAllReferences()) {
+                            result.references.add(eReference);
+                            result.referencesOfClass.get(eClass).add(eReference);
+                        }
+                    }
+                    if (getAttrbiutes) {
+                        result.attributesOfClass.put(eClass, new TreeSet<EAttribute>(comparator));
+                        for (EAttribute eAttribute : eClass.getEAllAttributes()) {
+                            result.attributes.add(eAttribute);
+                            result.attributesOfClass.get(eClass).add(eAttribute);
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/util/Hasher.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/util/Hasher.java
new file mode 100644
index 00000000..0c5d7eba
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/util/Hasher.java
@@ -0,0 +1,86 @@
+/*******************************************************************************

+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro

+ * This program and the accompanying materials are made available under the

+ * terms of the Eclipse Public License v. 2.0 which is available at

+ * http://www.eclipse.org/legal/epl-v20.html.

+ * 

+ * SPDX-License-Identifier: EPL-2.0

+ *******************************************************************************/

+package org.eclipse.viatra.dse.util;

+

+import java.math.BigInteger;

+import java.security.MessageDigest;

+import java.security.NoSuchAlgorithmException;

+

+import org.eclipse.viatra.dse.api.DSEException;

+

+/**

+ * Utility class that encapsulates a {@link MessageDigest} instance to aid calculating hash values more easily, and to

+ * reuse a {@link MessageDigest} instance.

+ * 

+ */

+public final class Hasher {

+    private MessageDigest md;

+

+    private static final int HEX = 16;

+

+    private Hasher(MessageDigest md) {

+        this.md = md;

+    }

+

+    /**

+     * Calculates and returns a hash value.

+     * 

+     * @param data

+     *            the data to be hashed in a {@link String}.

+     * @return the hash value in some {@link String} representation.

+     */

+    public String hash(String data) {

+        md.update(data.getBytes(), 0, data.length());

+        return new String(md.digest());

+    }

+

+    @SuppressWarnings("unused")

+    private String alternateHashBest(String data) {

+        md.update(data.getBytes(), 0, data.length());

+        return new String(md.digest());

+    }

+

+    @SuppressWarnings("unused")

+    private String alternateHashSecondBest(String data) {

+        md.update(data.getBytes(), 0, data.length());

+        return new BigInteger(1, md.digest()).toString(HEX);

+    }

+

+    @SuppressWarnings("unused")

+    private String alternateHashThirdBest(String data) {

+        md.update(data.getBytes(), 0, data.length());

+        byte[] array = md.digest();

+        StringBuilder sb = new StringBuilder();

+        for (int i = 0; i < array.length; i++) {

+            sb.append(Integer.toHexString((int) array[i]));

+        }

+        return sb.toString();

+    }

+

+    /**

+     * Returns a {@link Hasher} with an internal {@link MessageDigest} that is based on the protocol named

+     * {@code protocoll}.

+     * 

+     * @param protocoll

+     *            the name of the hash algorythm.

+     * @return the initialized {@link Hasher}

+     * 

+     * @throws DSEException

+     *             on initialization failure.

+     */

+    public static Hasher getHasher(String protocoll) {

+        try {

+            return new Hasher(MessageDigest.getInstance(protocoll));

+        } catch (NoSuchAlgorithmException e) {

+            throw new DSEException(e);

+        }

+    }

+

+    public static final String SHA1_PROTOCOLL = "SHA-1";

+}

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/util/ValueComparableEObjectStringMap.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/util/ValueComparableEObjectStringMap.java
new file mode 100644
index 00000000..49af05d1
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/util/ValueComparableEObjectStringMap.java
@@ -0,0 +1,63 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.util;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeMap;
+
+import org.eclipse.emf.ecore.EObject;
+
+import com.google.common.base.Functions;
+import com.google.common.collect.Ordering;
+
+/**
+ * 
+ * This custom {@link TreeMap} implementation enables to store {@link EObject}-{@link String} pairs sorted by values
+ * (strings). It works as expected if the map is modified in any way, hence the map will still be sorted by values on
+ * the new set of entries.
+ * 
+ * It is allowed to have two entries with the same EObject key (and also with same values).
+ * 
+ * The short coming of the class is that EObjects are compared to each other by their
+ * {@link System#identityHashCode(Object)}, which may lead to unexpected errors.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class ValueComparableEObjectStringMap extends TreeMap<EObject, String> {
+
+    private static final class EObjectComparator implements Comparator<EObject> {
+        @Override
+        public int compare(EObject o1, EObject o2) {
+            return Integer.valueOf(System.identityHashCode(o1)).compareTo(Integer.valueOf(System.identityHashCode(o2)));
+        }
+    }
+
+    private final Map<EObject, String> innerMap;
+
+    public ValueComparableEObjectStringMap() {
+        this(new HashMap<EObject, String>());
+    }
+
+    private ValueComparableEObjectStringMap(Map<EObject, String> innerMap) {
+        super(Ordering.natural().onResultOf(Functions.forMap(innerMap)).compound(new EObjectComparator()));
+        this.innerMap = innerMap;
+    }
+
+    @Override
+    public String put(EObject keyEObject, String stringValue) {
+        if (innerMap.containsKey(keyEObject)) {
+            remove(keyEObject);
+        }
+        innerMap.put(keyEObject, stringValue);
+        return super.put(keyEObject, stringValue);
+    }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/visualizer/DesignSpaceVisualizerOptions.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/visualizer/DesignSpaceVisualizerOptions.java
new file mode 100644
index 00000000..bb8000d5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/visualizer/DesignSpaceVisualizerOptions.java
@@ -0,0 +1,56 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.visualizer;
+
+public class DesignSpaceVisualizerOptions {
+
+    public boolean showExplorationTrace = true;
+    public boolean showStateCodes = true;
+    public boolean showTransitionCodes = true;
+
+    public DesignSpaceVisualizerOptions withOutExploraionTrace() {
+        showExplorationTrace = false;
+        return this;
+    }
+
+    public DesignSpaceVisualizerOptions withOutstateCodes() {
+        showStateCodes = false;
+        return this;
+    }
+
+    public DesignSpaceVisualizerOptions withOutTransitionCodes() {
+        showTransitionCodes = false;
+        return this;
+    }
+
+    public boolean isShowExplorationTrace() {
+        return showExplorationTrace;
+    }
+
+    public void setShowExplorationTrace(boolean showExplorationTrace) {
+        this.showExplorationTrace = showExplorationTrace;
+    }
+
+    public boolean isShowStateCodes() {
+        return showStateCodes;
+    }
+
+    public void setShowStateCodes(boolean showStateCodes) {
+        this.showStateCodes = showStateCodes;
+    }
+
+    public boolean isShowTransitionCodes() {
+        return showTransitionCodes;
+    }
+
+    public void setShowTransitionCodes(boolean showTransitionCodes) {
+        this.showTransitionCodes = showTransitionCodes;
+    }
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/visualizer/IDesignSpaceVisualizer.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/visualizer/IDesignSpaceVisualizer.java
new file mode 100644
index 00000000..da598b91
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/visualizer/IDesignSpaceVisualizer.java
@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.visualizer;
+
+import org.eclipse.viatra.dse.api.DesignSpaceExplorer;
+import org.eclipse.viatra.dse.base.ThreadContext;
+
+/**
+ * 
+ * An implementation of this interface is notified about the traversal of the design space from every traversing thread,
+ * if registered to the {@link DesignSpaceExplorer}. Its purpose is to able to visualize the design space (a directed
+ * graph with IDs of the nodes and transitions) and to able to visualize the order of the exploration (the trace of a
+ * thread).
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public interface IDesignSpaceVisualizer extends IExploreEventHandler {
+
+    /**
+     * Initializes the instance with a starting thread's context. Can be called multiple times and concurrently.
+     * 
+     * @see DesignSpaceVisualizerOptions
+     * @param context
+     */
+    void init(ThreadContext context);
+
+    /**
+     * Saves the captured data.
+     */
+    void save();
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/visualizer/IExploreEventHandler.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/visualizer/IExploreEventHandler.java
new file mode 100644
index 00000000..9f902f31
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.dse/src/org/eclipse/viatra/dse/visualizer/IExploreEventHandler.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.viatra.dse.visualizer;
+
+import org.eclipse.viatra.dse.base.DesignSpaceManager;
+
+/**
+ * An implementation of this interface is notified about every move in the design space (firing a rule activation or
+ * undoing it) of a single thread, if registered to the corresponding {@link DesignSpaceManager}. Its methods are called
+ * synchronously, therefore the implementation can have an impact on the performance. Also note, if the same instance is
+ * registered to multiple threads ({@link DesignSpaceManager}), it has to be thread safe.
+ * 
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public interface IExploreEventHandler {
+
+    /**
+     * Called by the {@link DesignSpaceManager}, after a rule activation (transition) is fired. Multiple calls with the
+     * same transition can occur.
+     * 
+     * @param transition The fired transition.
+     */
+    void transitionFired(Object transition);
+
+    /**
+     * Called by the {@link DesignSpaceManager}, after undoing the previously fired rule activation (transition).
+     * Multiple calls with the same transition can occur.
+     * 
+     * @param transition The undone transition.
+     */
+    void undo(Object transition);
+
+}