71 files changed, 7176 insertions, 1802 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..f9090901 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF
@@ -4,6 +4,9 @@ Bundle-Name: Logic2viatra
 Bundle-SymbolicName: hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatraquery;singleton:=true
 Bundle-Version: 1.0.0.qualifier
 Export-Package: hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.aggregators,
  hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns,
  hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries
 Require-Bundle: hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0",
@@ -20,7 +23,9 @@ Require-Bundle: hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0",
  com.google.inject;bundle-version="3.0.0",
  org.eclipse.xtext;bundle-version="2.10.0",
  org.eclipse.viatra.transformation.runtime.emf;bundle-version="1.5.0",
- org.eclipse.xtext.xbase;bundle-version="2.10.0"
+ org.eclipse.xtext.xbase;bundle-version="2.10.0",
+ com.microsoft.z3;bundle-version="4.8.5",
+ hu.bme.mit.inf.dslreasoner.ilp.cbc;bundle-version="1.0.0"
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Import-Package: org.apache.log4j
 Automatic-Module-Name: hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatraquery
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/build.properties b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/build.properties
index 585df5ce..9ffc994a 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/build.properties
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/build.properties
@@ -4,6 +4,5 @@ bin.includes = META-INF/,\
 source.. = src/,\

            patterns/,\

            vql-gen/,\

-           xtend-gen/,\

-           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
index f43ab96d..23632d4d 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend
@@ -1,8 +1,19 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra

 

+import com.google.common.collect.ImmutableMap

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.DocumentationLevel

 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem

 import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransfomedViatraQuery

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.CbcPolyhedronSolver

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.MultiplicityGoalConstraintCalculator

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronScopePropagator

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.RelationConstraintCalculator

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagator

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagatorStrategy

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.TypeHierarchyScopePropagator

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Z3PolyhedronSolver

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.ModalPatternQueries

 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PatternProvider

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

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

@@ -10,6 +21,7 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.par
 import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace

 import java.util.Collection

 import java.util.List

+import java.util.Map

 import java.util.Set

 import org.eclipse.viatra.query.runtime.api.IPatternMatch

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

@@ -20,63 +32,99 @@ import org.eclipse.xtend.lib.annotations.Data
 

 class ModelGenerationStatistics {

         public var long transformationExecutionTime = 0

+

         synchronized def addExecutionTime(long amount) {

-                transformationExecutionTime+=amount

+                transformationExecutionTime += amount

+        }

+

+        public var long scopePropagationTime = 0

+

+        synchronized def addScopePropagationTime(long amount) {

+                scopePropagationTime += amount

+        }

+

+        public var long preliminaryTypeAnalisisTime = 0

+

+        public var int decisionsTried = 0

+        

+        synchronized def incrementDecisionCount() {

+                decisionsTried++

+        }

+        

+        public var int scopePropagatorInvocations

+        

+        synchronized def incrementScopePropagationCount() {

+                scopePropagatorInvocations++

         }

-        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

+        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<String, ModalPatternQueries> modalRelationQueries

+

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

 }

+

 enum TypeInferenceMethod {

-        Generic, PreliminaryAnalysis

+        Generic,

+        PreliminaryAnalysis

 }

 

 class ModelGenerationMethodProvider {

-        private val PatternProvider patternProvider = new PatternProvider

-        private val RefinementRuleProvider refinementRuleProvider = new RefinementRuleProvider

-        private val GoalConstraintProvider goalConstraintProvider = new GoalConstraintProvider

-        

-        public def ModelGenerationMethod createModelGenerationMethod(

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

                 boolean nameNewElements,

                 TypeInferenceMethod typeInferenceMethod,

-                ScopePropagator scopePropagator,

+                ScopePropagatorStrategy scopePropagatorStrategy,

                 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 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, typeInferenceMethod, scopePropagatorStrategy, relationConstraints, writeFiles)

+                val scopePropagator = createScopePropagator(scopePropagatorStrategy, emptySolution, queries, statistics)

+                scopePropagator.propagateAllScopeConstraints

+                val objectRefinementRules = refinementRuleProvider.createObjectRefinementRules(queries, scopePropagator,

+                        nameNewElements, statistics)

+                val relationRefinementRules = refinementRuleProvider.createRelationRefinementRules(queries, scopePropagator,

+                        statistics)

+

                 val unfinishedMultiplicities = goalConstraintProvider.getUnfinishedMultiplicityQueries(queries)

                 val unfinishedWF = queries.getUnfinishedWFQueries.values

-                

+

+                val modalRelationQueriesBuilder = ImmutableMap.builder

+                for (entry : queries.modalRelationQueries.entrySet) {

+                        val annotation = entry.key.annotations.filter(TransfomedViatraQuery).head

+                        if (annotation !== null) {

+                                modalRelationQueriesBuilder.put(annotation.patternFullyQualifiedName, entry.value)

+                        }

+                }

+                val modalRelationQueries = modalRelationQueriesBuilder.build

+

                 val invalidWF = queries.getInvalidWFQueries.values

-                

+

                 return new ModelGenerationMethod(

                         statistics,

                         objectRefinementRules.values,

@@ -84,7 +132,38 @@ class ModelGenerationMethodProvider {
                         unfinishedMultiplicities,

                         unfinishedWF,

                         invalidWF,

+                        modalRelationQueries,

                         queries.allQueries

                 )

         }

+

+        private def createScopePropagator(ScopePropagatorStrategy scopePropagatorStrategy,

+                PartialInterpretation emptySolution, GeneratedPatterns queries, ModelGenerationStatistics statistics) {

+                switch (scopePropagatorStrategy) {

+                        case ScopePropagatorStrategy.Count:

+                                new ScopePropagator(emptySolution, statistics)

+                        case ScopePropagatorStrategy.BasicTypeHierarchy:

+                                new TypeHierarchyScopePropagator(emptySolution, statistics)

+                        ScopePropagatorStrategy.Polyhedral: {

+                                val types = queries.refineObjectQueries.keySet.map[newType].toSet

+                                val solver = switch (scopePropagatorStrategy.solver) {

+                                        case Z3Integer:

+                                                new Z3PolyhedronSolver(false, scopePropagatorStrategy.timeoutSeconds)

+                                        case Z3Real:

+                                                new Z3PolyhedronSolver(true, scopePropagatorStrategy.timeoutSeconds)

+                                        case Cbc:

+                                                new CbcPolyhedronSolver(false, scopePropagatorStrategy.timeoutSeconds, true)

+                                        case Clp:

+                                                new CbcPolyhedronSolver(true, scopePropagatorStrategy.timeoutSeconds, true)

+                                        default:

+                                                throw new IllegalArgumentException("Unknown polyhedron solver: " +

+                                                        scopePropagatorStrategy.solver)

+                                }

+                                new PolyhedronScopePropagator(emptySolution, statistics, types, queries.multiplicityConstraintQueries,

+                                        queries.hasElementInContainmentQuery, solver, scopePropagatorStrategy.requiresUpperBoundIndexing)

+                        }

+                        default:

+                                throw new IllegalArgumentException("Unknown scope propagator strategy: " + scopePropagatorStrategy)

+                }

+        }

 }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ScopePropagator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ScopePropagator.xtend
deleted file mode 100644
index 38633c07..00000000
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ScopePropagator.xtend
+++ /dev/null
@@ -1,156 +0,0 @@
-package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra

-

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope

-import java.util.HashMap

-import java.util.Map

-import java.util.Set

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

-import java.util.HashSet

-

-class ScopePropagator {

-        PartialInterpretation partialInterpretation

-        Map<PartialTypeInterpratation,Scope> type2Scope

-        

-        val Map<Scope, Set<Scope>> superScopes

-        val Map<Scope, Set<Scope>> subScopes

-        

-        public new(PartialInterpretation p) {

-                partialInterpretation = p

-                type2Scope = new HashMap

-                for(scope : p.scopes) {

-                        type2Scope.put(scope.targetTypeInterpretation,scope)

-                }

-                

-                superScopes = new HashMap

-                subScopes = new HashMap

-                for(scope : p.scopes) {

-                        superScopes.put(scope,new HashSet)

-                        subScopes.put(scope,new HashSet)

-                }

-                

-                for(scope : p.scopes) {

-                        val target = scope.targetTypeInterpretation

-                        if(target instanceof PartialComplexTypeInterpretation) {

-                                val supertypeInterpretations = target.supertypeInterpretation

-                                for(supertypeInterpretation : supertypeInterpretations) {

-                                        val supertypeScope = type2Scope.get(supertypeInterpretation)

-                                        superScopes.get(scope).add(supertypeScope)

-                                        subScopes.get(supertypeScope).add(scope)

-                                }

-                        }

-                }

-        }

-        

-        def public propagateAllScopeConstraints() {

-                var boolean hadChanged

-                do{

-                        hadChanged = false

-                        for(superScopeEntry : superScopes.entrySet) {

-                                val sub = superScopeEntry.key

-                                hadChanged = propagateLowerLimitUp(sub,partialInterpretation) || hadChanged

-                                hadChanged = propagateUpperLimitDown(sub,partialInterpretation) || hadChanged

-                                for(sup: superScopeEntry.value) {

-                                        hadChanged = propagateLowerLimitUp(sub,sup) || hadChanged

-                                        hadChanged = propagateUpperLimitDown(sub,sup) || hadChanged

-                                }

-                        }

-                } while(hadChanged)

-//              println('''All constraints are propagated.''')

-        }

-        

-        def public propagateAdditionToType(PartialTypeInterpratation t) {

-//              println('''Adding to «(t as PartialComplexTypeInterpretation).interpretationOf.name»''')

-                val targetScope = type2Scope.get(t)

-                targetScope.removeOne

-                val sups = superScopes.get(targetScope)

-                sups.forEach[removeOne]

-                if(this.partialInterpretation.minNewElements > 0) {

-                        this.partialInterpretation.minNewElements = this.partialInterpretation.minNewElements-1

-                }

-                if(this.partialInterpretation.maxNewElements > 0) {

-                        this.partialInterpretation.maxNewElements = this.partialInterpretation.maxNewElements-1

-                } else if(this.partialInterpretation.maxNewElements === 0) {

-                        throw new IllegalArgumentException('''Inconsistent object creation: lower node limit is 0!''')

-                }

-                

-//              subScopes.get(targetScope).forEach[propagateUpperLimitDown(it,targetScope)]

-//              for(sup: sups) {

-//                      subScopes.get(sup).forEach[propagateUpperLimitDown(it,sup)]

-//              }

-//              for(scope : type2Scope.values) {

-//                      propagateUpperLimitDown(scope,partialInterpretation)

-//              }

-

-                propagateAllScopeConstraints

-                

-//              println('''Target Scope: «targetScope.minNewElements» - «targetScope.maxNewElements»''')

-//              println(''' «this.partialInterpretation.minNewElements» - «this.partialInterpretation.maxNewElements»''')

-//              this.partialInterpretation.scopes.forEach[println(''' «(it.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name»: «it.minNewElements»-«it.maxNewElements»''')]

-//              println('''All constraints are propagated upon increasing «(t as PartialComplexTypeInterpretation).interpretationOf.name»''')

-        }

-        

-        private def propagateLowerLimitUp(Scope subScope, Scope superScope) {

-                if(subScope.minNewElements>superScope.minNewElements) {

-//                      println('''

-//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> «(superScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name»

-//                      superScope.minNewElements «superScope.minNewElements» = subScope.minNewElements «subScope.minNewElements»

-//                      ''')

-                        superScope.minNewElements = subScope.minNewElements

-                        return true

-                } else {

-                        return false

-                }

-        }

-        

-        private def propagateUpperLimitDown(Scope subScope, Scope superScope) {

-                if(superScope.maxNewElements>=0 && (superScope.maxNewElements<subScope.maxNewElements || subScope.maxNewElements<0)) {

-//                      println('''

-//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> «(superScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name»

-//                      subScope.maxNewElements «subScope.maxNewElements» = superScope.maxNewElements «superScope.maxNewElements»

-//                      ''')

-                        subScope.maxNewElements = superScope.maxNewElements

-                        return true

-                } else {

-                        return false

-                }

-        }

-        

-        private def propagateLowerLimitUp(Scope subScope, PartialInterpretation p) {

-                if(subScope.minNewElements>p.minNewElements) {

-//                      println('''

-//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> nodes

-//                      p.minNewElements «p.minNewElements» = subScope.minNewElements «subScope.minNewElements»

-//                      ''')

-                        p.minNewElements = subScope.minNewElements

-                        return true

-                } else {

-                        return false

-                }

-        }

-        

-        private def propagateUpperLimitDown(Scope subScope, PartialInterpretation p) {

-                if(p.maxNewElements>=0 && (p.maxNewElements<subScope.maxNewElements || subScope.maxNewElements<0)) {

-//                      println('''

-//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> nodes

-//                      subScope.maxNewElements «subScope.maxNewElements» = p.maxNewElements «p.maxNewElements»

-//                      ''')

-                        subScope.maxNewElements = p.maxNewElements

-                        return true

-                } else {

-                        return false

-                }

-        }

-        private def removeOne(Scope scope) {

-                if(scope.maxNewElements===0) {

-                        throw new IllegalArgumentException('''Inconsistent object creation: «scope.targetTypeInterpretation»''')

-                } else if(scope.maxNewElements>0) {

-                        scope.maxNewElements= scope.maxNewElements-1

-                }

-                if(scope.minNewElements>0) {

-                        scope.minNewElements= scope.minNewElements-1

-                }

-        }

-}

-                        
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/AbstractPolyhedronSaturationOperator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/AbstractPolyhedronSaturationOperator.xtend
new file mode 100644
index 00000000..94f97e94
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/AbstractPolyhedronSaturationOperator.xtend
@@ -0,0 +1,53 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import com.google.common.collect.ImmutableList
+import org.eclipse.xtend.lib.annotations.Accessors
+
+abstract class AbstractPolyhedronSaturationOperator implements PolyhedronSaturationOperator {
+        @Accessors val Polyhedron polyhedron
+
+        new(Polyhedron polyhedron) {
+                if (polyhedron.dimensions.empty) {
+                        throw new IllegalArgumentException("Polyhedron must have at least one dimension.")
+                }
+                this.polyhedron = polyhedron
+        }
+
+        override saturate() {
+                if (polyhedron.expressionsToSaturate.empty) {
+                        return PolyhedronSaturationResult.SATURATED
+                }
+                for (constraint : polyhedron.constraints) {
+                        if (constraint.zero) {
+                                if (constraint.lowerBound !== null && constraint.lowerBound > 0) {
+                                        return PolyhedronSaturationResult.EMPTY
+                                }
+                                if (constraint.upperBound !== null && constraint.upperBound < 0) {
+                                        return PolyhedronSaturationResult.EMPTY
+                                }
+                        } else {
+                                if (constraint.lowerBound !== null && constraint.upperBound !== null &&
+                                        constraint.upperBound < constraint.lowerBound) {
+                                        return PolyhedronSaturationResult.EMPTY
+                                }
+                        }
+                }
+                doSaturate()
+        }
+
+        protected def PolyhedronSaturationResult doSaturate()
+
+        protected def getNonTrivialConstraints() {
+                ImmutableList.copyOf(polyhedron.constraints.filter [ constraint |
+                        (constraint.lowerBound !== null || constraint.upperBound !== null) && !constraint.zero
+                ])
+        }
+
+        private static def isZero(LinearConstraint constraint) {
+                constraint.coefficients.values.forall[it == 0]
+        }
+
+        override close() throws Exception {
+                // Nothing to close by default.
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/CbcPolyhedronSolver.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/CbcPolyhedronSolver.xtend
new file mode 100644
index 00000000..4bd46fbf
--- /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,216 @@
+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 {
+        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 value = Math.floor(minimizationResult.value)
+                                expressionToSaturate.lowerBound = value as int
+                                setBound(expressionToSaturate, constraints, value, columnLowerBounds, rowLowerBounds)
+                        }
+                        case CbcResult.SOLUTION_UNBOUNDED: {
+                                expressionToSaturate.lowerBound = null
+                                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 value = Math.ceil(-maximizationResult.value)
+                                expressionToSaturate.upperBound = value as int
+                                setBound(expressionToSaturate, constraints, value, columnUpperBounds, rowUpperBounds)
+                        }
+                        case CbcResult.SOLUTION_UNBOUNDED: {
+                                expressionToSaturate.upperBound = null
+                                setBound(expressionToSaturate, constraints, Double.POSITIVE_INFINITY, columnUpperBounds, rowUpperBounds)
+                        }
+                        case CbcResult.UNSAT:
+                                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/MultiplicityGoalConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/MultiplicityGoalConstraintCalculator.xtend
index e05160d0..86a59aa1 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/MultiplicityGoalConstraintCalculator.xtend
@@ -1,4 +1,4 @@
-package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra

+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality

 

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

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

@@ -11,36 +11,36 @@ class MultiplicityGoalConstraintCalculator {
         val IQuerySpecification<?> querySpecification;

         var ViatraQueryMatcher<?> matcher;

                 

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

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

                 this.targetRelationName = targetRelationName

                 this.querySpecification = querySpecification

                 this.matcher = null

         }

         

-        public new(MultiplicityGoalConstraintCalculator other) {

+        new(MultiplicityGoalConstraintCalculator other) {

                 this.targetRelationName = other.targetRelationName

                 this.querySpecification = other.querySpecification

                 this.matcher = null

         }

         

-        def public getName() {

+        def getName() {

                 targetRelationName

         }

         

-        def public init(Notifier notifier) {

+        def init(Notifier notifier) {

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

                 matcher = querySpecification.getMatcher(engine)

         }

         

-        def public calculateValue() {

+        def calculateValue() {

                 var res = 0

                 val allMatches = this.matcher.allMatches

                 for(match : allMatches) {

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

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

+                        val missingMultiplicity = match.get(2) 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/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..7c05e818
--- /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,516 @@
+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.HashMap
+import java.util.HashSet
+import java.util.List
+import java.util.Map
+import java.util.Set
+import javax.naming.OperationNotSupportedException
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.viatra.query.runtime.emf.EMFScope
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+class PolyhedronScopePropagator extends TypeHierarchyScopePropagator {
+        val Map<Scope, LinearBoundedExpression> scopeBounds
+        val LinearBoundedExpression topLevelBounds
+        val Polyhedron polyhedron
+        val PolyhedronSaturationOperator operator
+        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,
+                PolyhedronSolver solver, boolean propagateRelations) {
+                super(p, statistics)
+                val builder = new PolyhedronBuilder(p)
+                builder.buildPolyhedron(possibleNewDynamicTypes)
+                scopeBounds = builder.scopeBounds
+                topLevelBounds = builder.topLevelBounds
+                polyhedron = builder.polyhedron
+                operator = solver.createSaturationOperator(polyhedron)
+                if (propagateRelations) {
+                        propagateAllScopeConstraints()
+                        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,
+                                maximumNumberOfNewNodes)
+                        relevantRelations = builder.relevantRelations
+                        updaters = builder.updaters
+                } else {
+                        relevantRelations = emptySet
+                }
+        }
+
+        override void doPropagateAllScopeConstraints() {
+                resetBounds()
+                populatePolyhedronFromScope()
+//              println(polyhedron)
+                val result = operator.saturate()
+//              println(polyhedron)
+                if (result == PolyhedronSaturationResult.EMPTY) {
+                        setScopesInvalid()
+                } else {
+                        populateScopesFromPolyhedron()
+                        if (result != PolyhedronSaturationResult.SATURATED) {
+                                super.propagateAllScopeConstraints()
+                        }
+                }
+        }
+        
+        override propagateAdditionToRelation(Relation r) {
+                super.propagateAdditionToRelation(r)
+                if (relevantRelations.contains(r)) {
+                        propagateAllScopeConstraints()
+                }
+        }
+
+        def resetBounds() {
+                for (dimension : polyhedron.dimensions) {
+                        dimension.lowerBound = 0
+                        dimension.upperBound = null
+                }
+                for (constraint : polyhedron.constraints) {
+                        constraint.lowerBound = null
+                        constraint.upperBound = null
+                }
+        }
+
+        private def populatePolyhedronFromScope() {
+                topLevelBounds.tightenLowerBound(partialInterpretation.minNewElements)
+                if (partialInterpretation.maxNewElements >= 0) {
+                        topLevelBounds.tightenUpperBound(partialInterpretation.maxNewElements)
+                }
+                for (pair : scopeBounds.entrySet) {
+                        val scope = pair.key
+                        val bounds = pair.value
+                        bounds.tightenLowerBound(scope.minNewElements)
+                        if (scope.maxNewElements >= 0) {
+                                bounds.tightenUpperBound(scope.maxNewElements)
+                        }
+                }
+                for (updater : updaters) {
+                        updater.update(partialInterpretation)
+                }
+        }
+
+        private def populateScopesFromPolyhedron() {
+                checkBounds(topLevelBounds)
+                if (partialInterpretation.minNewElements > topLevelBounds.lowerBound) {
+                        throw new IllegalArgumentException('''Lower bound of «topLevelBounds» smaller than top-level scope: «partialInterpretation.minNewElements»''')
+                } else if (partialInterpretation.minNewElements != topLevelBounds.lowerBound) {
+                        partialInterpretation.minNewElements = topLevelBounds.lowerBound
+                }
+                val topLevelUpperBound = topLevelBounds.upperBound ?: -1
+                if (partialInterpretation.maxNewElements >= 0 && topLevelUpperBound >= 0 &&
+                        partialInterpretation.maxNewElements < topLevelUpperBound) {
+                        throw new IllegalArgumentException('''Upper bound of «topLevelBounds» larger than top-level scope: «partialInterpretation.maxNewElements»''')
+                } else if (partialInterpretation.maxNewElements != topLevelUpperBound) {
+                        partialInterpretation.maxNewElements = topLevelUpperBound
+                }
+                for (pair : scopeBounds.entrySet) {
+                        val scope = pair.key
+                        val bounds = pair.value
+                        checkBounds(bounds)
+                        if (scope.minNewElements > bounds.lowerBound) {
+                                throw new IllegalArgumentException('''Lower bound of «bounds» smaller than «scope.targetTypeInterpretation» scope: «scope.minNewElements»''')
+                        } else if (scope.minNewElements != bounds.lowerBound) {
+                                scope.minNewElements = bounds.lowerBound
+                        }
+                        val upperBound = bounds.upperBound ?: -1
+                        if (scope.maxNewElements >= 0 && upperBound >= 0 && scope.maxNewElements < upperBound) {
+                                throw new IllegalArgumentException('''Upper bound of «bounds» larger than «scope.targetTypeInterpretation» scope: «scope.maxNewElements»''')
+                        } else if (scope.maxNewElements != upperBound) {
+                                scope.maxNewElements = upperBound
+                        }
+                }
+        }
+
+        private def checkBounds(LinearBoundedExpression bounds) {
+                if (bounds.lowerBound === null) {
+                        throw new IllegalArgumentException("Infinite lower bound: " + bounds)
+                } else if (bounds.lowerBound < 0) {
+                        throw new IllegalArgumentException("Negative lower bound: " + bounds)
+                }
+                if (bounds.upperBound !== null && bounds.upperBound < 0) {
+                        throw new IllegalArgumentException("Negative upper bound: " + bounds)
+                }
+        }
+
+        private def setScopesInvalid() {
+                partialInterpretation.minNewElements = Integer.MAX_VALUE
+                partialInterpretation.maxNewElements = 0
+                for (scope : partialInterpretation.scopes) {
+                        scope.minNewElements = Integer.MAX_VALUE
+                        scope.maxNewElements = 0
+                }
+        }
+
+        private static def <T extends IPatternMatch> getCalculatedMultiplicity(ViatraQueryMatcher<T> matcher,
+                PartialInterpretation p) {
+                val match = matcher.newEmptyMatch
+                match.set(0, p.problem)
+                match.set(1, p)
+                val iterator = matcher.streamAllMatches(match).iterator
+                if (!iterator.hasNext) {
+                        return null
+                }
+                val value = iterator.next.get(2) as Integer
+                if (iterator.hasNext) {
+                        throw new IllegalArgumentException("Multiplicity calculation query has more than one match")
+                }
+                value
+        }
+
+        @FinalFieldsConstructor
+        private static class PolyhedronBuilder {
+                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
+                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,
+                        int maximumNuberOfNewNodes) {
+                        infinity = maximumNuberOfNewNodes * INFINITY_SCALE
+                        queryEngine = ViatraQueryEngine.on(new EMFScope(p))
+                        updatersBuilder = ImmutableList.builder
+                        val containmentConstraints = constraints.entrySet.filter[key.containment].groupBy[key.targetType]
+                        for (pair : containmentConstraints.entrySet) {
+                                buildContainmentConstraints(pair.key, pair.value)
+                        }
+                        buildConstainmentRootConstraints(containmentConstraints.keySet, hasElementInContainmentQuery)
+                        for (pair : constraints.entrySet) {
+                                val constraint = pair.key
+                                if (!constraint.containment) {
+                                        buildNonContainmentConstraints(constraint, pair.value)
+                                }
+                        }
+                        buildRelevantRelations(constraints.keySet)
+                        updaters = updatersBuilder.build
+                        addCachedConstraintsToPolyhedron()
+                }
+                
+                private def buildRelevantRelations(Set<RelationMultiplicityConstraint> constraints) {
+                        val builder = ImmutableSet.builder
+                        for (constraint : constraints) {
+                                builder.add(constraint.relation)
+                                if (constraint.inverseRelation !== null) {
+                                        builder.add(constraint.inverseRelation)
+                                }
+                        }
+                        relevantRelations = builder.build
+                }
+
+                private def addCachedConstraintsToPolyhedron() {
+                        val constraints = new HashSet
+                        constraints.addAll(expressionsCache.values.filter(LinearConstraint))
+                        constraints.removeAll(polyhedron.constraints)
+                        polyhedron.constraints.addAll(constraints)
+                }
+
+                private def buildContainmentConstraints(Type containedType,
+                        List<Map.Entry<RelationMultiplicityConstraint, UnifinishedMultiplicityQueries>> constraints) {
+                        val typeCoefficients = subtypeDimensions.get(containedType)
+                        val orphansLowerBoundCoefficients = new HashMap(typeCoefficients)
+                        val orphansUpperBoundCoefficients = new HashMap(typeCoefficients)
+                        val unfinishedMultiplicitiesMatchersBuilder = ImmutableList.builder
+                        val remainingContentsQueriesBuilder = ImmutableList.builder
+                        for (pair : constraints) {
+                                val constraint = pair.key
+                                val containerCoefficients = subtypeDimensions.get(constraint.sourceType)
+                                if (constraint.isUpperBoundFinite) {
+                                        orphansLowerBoundCoefficients.addCoefficients(-constraint.upperBound, containerCoefficients)
+                                } else {
+                                        orphansLowerBoundCoefficients.addCoefficients(-infinity, containerCoefficients)
+                                }
+                                orphansUpperBoundCoefficients.addCoefficients(-constraint.lowerBound, containerCoefficients)
+                                val queries = pair.value
+                                if (constraint.constrainsUnfinished) {
+                                        if (queries.unfinishedMultiplicityQuery === null) {
+                                                throw new IllegalArgumentException(
+                                                        "Containment constraints need unfinished multiplicity queries")
+                                        }
+                                        unfinishedMultiplicitiesMatchersBuilder.add(
+                                                queries.unfinishedMultiplicityQuery.getMatcher(queryEngine))
+                                }
+                                if (queries.remainingContentsQuery === null) {
+                                        throw new IllegalArgumentException("Containment constraints need remaining contents queries")
+                                }
+                                remainingContentsQueriesBuilder.add(queries.remainingContentsQuery.getMatcher(queryEngine))
+                        }
+                        val orphanLowerBound = orphansLowerBoundCoefficients.toExpression
+                        val orphanUpperBound = orphansUpperBoundCoefficients.toExpression
+                        val updater = new ContainmentConstraintUpdater(containedType.name, orphanLowerBound, orphanUpperBound,
+                                unfinishedMultiplicitiesMatchersBuilder.build, remainingContentsQueriesBuilder.build)
+                        updatersBuilder.add(updater)
+                }
+
+                private def buildConstainmentRootConstraints(Set<Type> containedTypes,
+                        IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hasElementInContainmentQuery) {
+                        val matcher = hasElementInContainmentQuery.getMatcher(queryEngine)
+                        val rootDimensions = Sets.newHashSet(instanceCounts.values)
+                        for (type : containedTypes) {
+                                val containedDimensions = subtypeDimensions.get(type).keySet
+                                rootDimensions.removeAll(containedDimensions)
+                        }
+                        for (dimension : rootDimensions) {
+                                updatersBuilder.add(new ContainmentRootConstraintUpdater(dimension, matcher))
+                        }
+                }
+
+                private def buildNonContainmentConstraints(RelationMultiplicityConstraint constraint,
+                        UnifinishedMultiplicityQueries queries) {
+                        if (constraint.constrainsRemainingInverse) {
+                                if (queries.unfinishedMultiplicityQuery === null) {
+                                        throw new IllegalArgumentException("Reference constraints need unfinished multiplicity queries")
+                                }
+                                val unfinishedMultiplicityMatcher = queries.unfinishedMultiplicityQuery.getMatcher(queryEngine)
+                                if (queries.remainingInverseMultiplicityQuery === null) {
+                                        throw new IllegalArgumentException(
+                                                "Reference constraints need remaining inverse multiplicity queries")
+                                }
+                                val remainingInverseMultiplicityMatcher = queries.remainingInverseMultiplicityQuery.getMatcher(
+                                        queryEngine)
+                                val availableMultiplicityCoefficients = new HashMap
+                                availableMultiplicityCoefficients.addCoefficients(constraint.inverseUpperBound,
+                                        subtypeDimensions.get(constraint.targetType))
+                                availableMultiplicityCoefficients.addCoefficients(-constraint.lowerBound,
+                                        subtypeDimensions.get(constraint.targetType))
+                                val availableMultiplicity = availableMultiplicityCoefficients.toExpression
+                                updatersBuilder.add(
+                                        new UnfinishedMultiplicityConstraintUpdater(constraint.relation.name, availableMultiplicity,
+                                                unfinishedMultiplicityMatcher, remainingInverseMultiplicityMatcher))
+                        }
+                        if (constraint.constrainsUnrepairable) {
+                                if (queries.unrepairableMultiplicityQuery === null) {
+                                        throw new IllegalArgumentException("Reference constraints need unrepairable multiplicity queries")
+                                }
+                                val unrepairableMultiplicityMatcher = queries.unrepairableMultiplicityQuery.getMatcher(queryEngine)
+                                val targetTypeCardinality = typeBounds.get(constraint.targetType)
+                                updatersBuilder.add(
+                                        new UnrepairableMultiplicityConstraintUpdater(constraint.relation.name, targetTypeCardinality,
+                                                unrepairableMultiplicityMatcher))
+                        }
+                }
+
+                private def addCoefficients(Map<Dimension, Integer> accumulator, int scale, Map<Dimension, Integer> a) {
+                        for (pair : a.entrySet) {
+                                val dimension = pair.key
+                                val currentValue = accumulator.get(pair.key) ?: 0
+                                val newValue = currentValue + scale * pair.value
+                                if (newValue == 0) {
+                                        accumulator.remove(dimension)
+                                } else {
+                                        accumulator.put(dimension, newValue)
+                                }
+                        }
+                }
+
+                private def findSubtypeDimensions(Type type) {
+                        val subtypes = new HashSet
+                        val dimensions = new HashSet
+                        val stack = new ArrayDeque
+                        stack.addLast(type)
+                        while (!stack.empty) {
+                                val subtype = stack.removeLast
+                                if (subtypes.add(subtype)) {
+                                        val dimension = instanceCounts.get(subtype)
+                                        if (dimension !== null) {
+                                                dimensions.add(dimension)
+                                        }
+                                        stack.addAll(subtype.subtypes)
+                                }
+                        }
+                        dimensions
+                }
+
+                private def toExpression(Map<Dimension, Integer> coefficients) {
+                        expressionsCache.computeIfAbsent(coefficients) [ c |
+                                if (c.size == 1 && c.entrySet.head.value == 1) {
+                                        c.entrySet.head.key
+                                } else {
+                                        new LinearConstraint(c, null, null)
+                                }
+                        ]
+                }
+
+                private def buildScopeBounds() {
+                        val scopeBoundsBuilder = ImmutableMap.builder
+                        for (scope : p.scopes) {
+                                switch (targetTypeInterpretation : scope.targetTypeInterpretation) {
+                                        PartialPrimitiveInterpretation:
+                                                throw new OperationNotSupportedException("Primitive type scopes are not yet implemented")
+                                        PartialComplexTypeInterpretation: {
+                                                val complexType = targetTypeInterpretation.interpretationOf
+                                                val typeBound = typeBounds.get(complexType)
+                                                if (typeBound === null) {
+                                                        if (scope.minNewElements > 0) {
+                                                                throw new IllegalArgumentException("Found scope for " + complexType.name +
+                                                                        ", but the type cannot be instantiated")
+                                                        }
+                                                } else {
+                                                        scopeBoundsBuilder.put(scope, typeBound)
+                                                }
+                                        }
+                                        default:
+                                                throw new IllegalArgumentException("Unknown PartialTypeInterpretation: " +
+                                                        targetTypeInterpretation)
+                                }
+                        }
+                        scopeBoundsBuilder.build
+                }
+        }
+
+        private static interface RelationConstraintUpdater {
+                def void update(PartialInterpretation p)
+        }
+
+        @FinalFieldsConstructor
+        static class ContainmentConstraintUpdater implements RelationConstraintUpdater {
+                val String name
+                val LinearBoundedExpression orphansLowerBound
+                val LinearBoundedExpression orphansUpperBound
+                val List<ViatraQueryMatcher<? extends IPatternMatch>> unfinishedMultiplicitiesMatchers
+                val List<ViatraQueryMatcher<? extends IPatternMatch>> remainingContentsQueries
+
+                override update(PartialInterpretation p) {
+                        tightenLowerBound(p)
+                        tightenUpperBound(p)
+                }
+
+                private def tightenLowerBound(PartialInterpretation p) {
+                        var int sum = 0
+                        for (matcher : remainingContentsQueries) {
+                                val value = matcher.getCalculatedMultiplicity(p)
+                                if (value === null) {
+                                        throw new IllegalArgumentException("Remaining contents count is missing for " + name)
+                                }
+                                if (value == -1) {
+                                        // Infinite upper bound, no need to tighten.
+                                        return
+                                }
+                                sum += value
+                        }
+                        orphansLowerBound.tightenUpperBound(sum)
+                }
+
+                private def tightenUpperBound(PartialInterpretation p) {
+                        var int sum = 0
+                        for (matcher : unfinishedMultiplicitiesMatchers) {
+                                val value = matcher.getCalculatedMultiplicity(p)
+                                if (value === null) {
+                                        throw new IllegalArgumentException("Unfinished multiplicity is missing for " + name)
+                                }
+                                sum += value
+                        }
+                        orphansUpperBound.tightenLowerBound(sum)
+                }
+        }
+
+        @FinalFieldsConstructor
+        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
+        static class UnfinishedMultiplicityConstraintUpdater implements RelationConstraintUpdater {
+                val String name
+                val LinearBoundedExpression availableMultiplicityExpression
+                val ViatraQueryMatcher<? extends IPatternMatch> unfinishedMultiplicityMatcher
+                val ViatraQueryMatcher<? extends IPatternMatch> remainingInverseMultiplicityMatcher
+
+                override update(PartialInterpretation p) {
+                        val unfinishedMultiplicity = unfinishedMultiplicityMatcher.getCalculatedMultiplicity(p)
+                        if (unfinishedMultiplicity === null) {
+                                throw new IllegalArgumentException("Unfinished multiplicity is missing for " + name)
+                        }
+                        val remainingInverseMultiplicity = remainingInverseMultiplicityMatcher.getCalculatedMultiplicity(p)
+                        if (remainingInverseMultiplicity === null) {
+                                throw new IllegalArgumentException("Remaining inverse multiplicity is missing for " + name)
+                        }
+                        val int requiredMultiplicity = unfinishedMultiplicity - remainingInverseMultiplicity
+                        availableMultiplicityExpression.tightenLowerBound(requiredMultiplicity)
+                }
+        }
+
+        @FinalFieldsConstructor
+        static class UnrepairableMultiplicityConstraintUpdater implements RelationConstraintUpdater {
+                val String name
+                val LinearBoundedExpression targetCardinalityExpression
+                val ViatraQueryMatcher<? extends IPatternMatch> unrepairableMultiplicityMatcher
+
+                override update(PartialInterpretation p) {
+                        val value = unrepairableMultiplicityMatcher.getCalculatedMultiplicity(p)
+                        if (value === null) {
+                                throw new IllegalArgumentException("Unrepairable multiplicity is missing for " + name)
+                        }
+                        targetCardinalityExpression.tightenLowerBound(value)
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronSolver.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronSolver.xtend
new file mode 100644
index 00000000..9c6cb82e
--- /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,123 @@
+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.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»
+        '''
+
+}
+
+@Accessors
+abstract class LinearBoundedExpression {
+        var Integer lowerBound
+        var Integer upperBound
+
+        def void tightenLowerBound(Integer tighterBound) {
+                if (lowerBound === null || (tighterBound !== null && lowerBound < tighterBound)) {
+                        lowerBound = tighterBound
+                }
+        }
+
+        def void tightenUpperBound(Integer tighterBound) {
+                if (upperBound === null || (tighterBound !== null && upperBound > tighterBound)) {
+                        upperBound = tighterBound
+                }
+        }
+}
+
+@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..52a390a8
--- /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,134 @@
+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() {
+                constrainsUnfinished && canHaveMultipleSourcesPerTarget
+        }
+
+        def constrainsRemainingInverse() {
+                lowerBound >= 1 && !containment && inverseUpperBoundFinite
+        }
+
+        def constrainsRemainingContents() {
+                containment
+        }
+
+        def isActive() {
+                constrainsUnfinished || constrainsUnrepairable || constrainsRemainingInverse || constrainsRemainingContents
+        }
+
+        def getSourceType() {
+                getParamType(0)
+        }
+
+        def getTargetType() {
+                getParamType(1)
+        }
+
+        private def getParamType(int i) {
+                val parameters = relation.parameters
+                if (i < parameters.size) {
+                        val firstParam = parameters.get(i)
+                        if (firstParam instanceof ComplexTypeReference) {
+                                return firstParam.referred
+                        }
+                }
+                throw new IllegalArgumentException("Constraint with unknown source type")
+        }
+}
+
+class RelationConstraintCalculator {
+        def calculateRelationConstraints(LogicProblem problem) {
+                val containmentRelations = switch (problem.containmentHierarchies.size) {
+                        case 0:
+                                <Relation>emptySet
+                        case 1:
+                                ImmutableSet.copyOf(problem.containmentHierarchies.head.containmentRelations)
+                        default:
+                                throw new IllegalArgumentException("Only a single containment hierarchy is supported")
+                }
+                val inverseRelations = new HashMap<Relation, Relation>
+                val lowerMultiplicities = new HashMap<Relation, Integer>
+                val upperMultiplicities = new HashMap<Relation, Integer>
+                for (relation : problem.relations) {
+                        lowerMultiplicities.put(relation, 0)
+                        upperMultiplicities.put(relation, -1)
+                }
+                for (annotation : problem.annotations) {
+                        switch (annotation) {
+                                InverseRelationAssertion: {
+                                        inverseRelations.put(annotation.inverseA, annotation.inverseB)
+                                        inverseRelations.put(annotation.inverseB, annotation.inverseA)
+                                }
+                                LowerMultiplicityAssertion:
+                                        lowerMultiplicities.put(annotation.relation, annotation.lower)
+                                UpperMultiplicityAssertion:
+                                        upperMultiplicities.put(annotation.relation, annotation.upper)
+                        }
+                }
+                val multiplicityConstraintsBuilder = ImmutableList.builder()
+                for (relation : problem.relations) {
+                        val containment = containmentRelations.contains(relation)
+                        val lowerMultiplicity = lowerMultiplicities.get(relation)
+                        val upperMultiplicity = upperMultiplicities.get(relation)
+                        var container = false
+                        var inverseUpperMultiplicity = -1
+                        val inverseRelation = inverseRelations.get(relation)
+                        if (inverseRelation !== null) {
+                                inverseUpperMultiplicity = upperMultiplicities.get(relation)
+                                container = containmentRelations.contains(inverseRelation)
+                        }
+                        val constraint = new RelationMultiplicityConstraint(relation, inverseRelation, containment, container,
+                                lowerMultiplicity, upperMultiplicity, inverseUpperMultiplicity)
+                        if (constraint.isActive) {
+                                if (relation.parameters.size != 2) {
+                                        throw new IllegalArgumentException('''Relation «relation.name» has multiplicity or containment constraints, but it is not binary''')
+                                }
+                                multiplicityConstraintsBuilder.add(constraint)
+                        }
+                }
+                new RelationConstraints(multiplicityConstraintsBuilder.build)
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagator.xtend
new file mode 100644
index 00000000..0bdb202e
--- /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,109 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality

+

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

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

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope

+import java.util.HashMap

+import java.util.HashSet

+import java.util.Map

+import java.util.Set

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

+

+class ScopePropagator {

+        @Accessors(PROTECTED_GETTER) val PartialInterpretation partialInterpretation

+        val ModelGenerationStatistics statistics

+        val Map<PartialTypeInterpratation, Scope> type2Scope

+        @Accessors(PROTECTED_GETTER) val Map<Scope, Set<Scope>> superScopes

+        @Accessors(PROTECTED_GETTER) val Map<Scope, Set<Scope>> subScopes

+

+        new(PartialInterpretation p, ModelGenerationStatistics statistics) {

+                partialInterpretation = p

+                this.statistics = statistics

+                type2Scope = new HashMap

+                for (scope : p.scopes) {

+                        type2Scope.put(scope.targetTypeInterpretation, scope)

+                }

+

+                superScopes = new HashMap

+                subScopes = new HashMap

+                for (scope : p.scopes) {

+                        superScopes.put(scope, new HashSet)

+                        subScopes.put(scope, new HashSet)

+                }

+

+                for (scope : p.scopes) {

+                        val target = scope.targetTypeInterpretation

+                        if (target instanceof PartialComplexTypeInterpretation) {

+                                val supertypeInterpretations = target.supertypeInterpretation

+                                for (supertypeInterpretation : supertypeInterpretations) {

+                                        val supertypeScope = type2Scope.get(supertypeInterpretation)

+                                        superScopes.get(scope).add(supertypeScope)

+                                        subScopes.get(supertypeScope).add(scope)

+                                }

+                        }

+                }

+                var boolean changed

+                do {

+                        changed = false

+                        for (scope : p.scopes) {

+                                val subScopeSet = subScopes.get(scope)

+                                val superScopeSet = superScopes.get(scope)

+                                for (subScope : subScopeSet) {

+                                        changed = changed || superScopes.get(subScope).addAll(superScopeSet)

+                                }

+                                for (superScope : superScopeSet) {

+                                        changed = changed || subScopes.get(superScope).addAll(subScopeSet)

+                                }

+                        }

+                } while (changed)

+        }

+

+        def propagateAllScopeConstraints() {

+                statistics.incrementScopePropagationCount()

+                doPropagateAllScopeConstraints()

+        }

+

+        protected def void doPropagateAllScopeConstraints() {

+                // Nothing to propagate.

+        }

+

+        def propagateAdditionToType(PartialTypeInterpratation t) {

+//              println('''Adding to «(t as PartialComplexTypeInterpretation).interpretationOf.name»''')

+                val targetScope = type2Scope.get(t)

+                targetScope.removeOne

+                val sups = superScopes.get(targetScope)

+                sups.forEach[removeOne]

+                if (this.partialInterpretation.minNewElements > 0) {

+                        this.partialInterpretation.minNewElements = this.partialInterpretation.minNewElements - 1

+                }

+                if (this.partialInterpretation.maxNewElements > 0) {

+                        this.partialInterpretation.maxNewElements = this.partialInterpretation.maxNewElements - 1

+                } else if (this.partialInterpretation.maxNewElements === 0) {

+                        throw new IllegalArgumentException('''Inconsistent object creation: lower node limit is 0!''')

+                }

+                propagateAllScopeConstraints

+

+//              println('''Target Scope: «targetScope.minNewElements» - «targetScope.maxNewElements»''')

+//              println(''' «this.partialInterpretation.minNewElements» - «this.partialInterpretation.maxNewElements»''')

+//              this.partialInterpretation.scopes.forEach[println(''' «(it.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name»: «it.minNewElements»-«it.maxNewElements»''')]

+//              println('''All constraints are propagated upon increasing «(t as PartialComplexTypeInterpretation).interpretationOf.name»''')

+        }

+

+        def void propagateAdditionToRelation(Relation r) {

+                // Nothing to propagate.

+        }

+

+        private def removeOne(Scope scope) {

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

+                        throw new IllegalArgumentException('''Inconsistent object creation: «scope.targetTypeInterpretation»''')

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

+                        scope.maxNewElements = scope.maxNewElements - 1

+                }

+                if (scope.minNewElements > 0) {

+                        scope.minNewElements = scope.minNewElements - 1

+                }

+        }

+}

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..b0ed75cb
--- /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,64 @@
+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 Count = new Simple("Count")
+
+        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 double timeoutSeconds
+
+                @FinalFieldsConstructor
+                new() {
+                }
+
+                new(PolyhedralScopePropagatorConstraints constraints, PolyhedralScopePropagatorSolver solver) {
+                        this(constraints, solver, UNLIMITED_TIME)
+                }
+
+                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..be8ef00a
--- /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,77 @@
+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) {
+                if (subScope.minNewElements > superScope.minNewElements) {
+                        superScope.minNewElements = subScope.minNewElements
+                        return true
+                } else {
+                        return false
+                }
+        }
+
+        private def propagateUpperLimitDown(Scope subScope, Scope superScope) {
+                if (superScope.maxNewElements >= 0 &&
+                        (superScope.maxNewElements < subScope.maxNewElements || subScope.maxNewElements < 0)) {
+//                      println('''
+//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> «(superScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name»
+//                      subScope.maxNewElements «subScope.maxNewElements» = superScope.maxNewElements «superScope.maxNewElements»
+//                      ''')
+                        subScope.maxNewElements = superScope.maxNewElements
+                        return true
+                } else {
+                        return false
+                }
+        }
+
+        private def propagateLowerLimitUp(Scope subScope, PartialInterpretation p) {
+                if (subScope.minNewElements > p.minNewElements) {
+//                      println('''
+//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> nodes
+//                      p.minNewElements «p.minNewElements» = subScope.minNewElements «subScope.minNewElements»
+//                      ''')
+                        p.minNewElements = subScope.minNewElements
+                        return true
+                } else {
+                        return false
+                }
+        }
+
+        private def propagateUpperLimitDown(Scope subScope, PartialInterpretation p) {
+                if (p.maxNewElements >= 0 && (p.maxNewElements < subScope.maxNewElements || subScope.maxNewElements < 0)) {
+//                      println('''
+//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> nodes
+//                      subScope.maxNewElements «subScope.maxNewElements» = p.maxNewElements «p.maxNewElements»
+//                      ''')
+                        subScope.maxNewElements = p.maxNewElements
+                        return true
+                } else {
+                        return false
+                }
+        }
+}
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..23444956
--- /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,248 @@
+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.FinalFieldsConstructor
+
+class Z3PolyhedronSolver implements PolyhedronSolver {
+        val boolean lpRelaxation
+        val double timeoutSeconds
+
+        @FinalFieldsConstructor
+        new() {
+        }
+
+        new() {
+                this(false, -1)
+        }
+
+        override createSaturationOperator(Polyhedron polyhedron) {
+                new Z3SaturationOperator(polyhedron, lpRelaxation, timeoutSeconds)
+        }
+}
+
+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:
+                                        floor(resultExpr)
+                                AlgebraicNum:
+                                        floor(resultExpr.toLower(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:
+                                        ceil(resultExpr)
+                                AlgebraicNum:
+                                        ceil(resultExpr.toUpper(ALGEBRAIC_NUMBER_ROUNDING))
+                                default:
+                                        if (isPositiveInfinity(resultExpr)) {
+                                                null
+                                        } else {
+                                                throw new IllegalArgumentException("Integer result expected, got: " + resultExpr)
+                                        }
+                        }
+                        expressionToSaturate.upperBound = value
+                }
+                status
+        }
+
+        private def ceil(RatNum ratNum) {
+                val numerator = new BigDecimal(ratNum.numerator.bigInteger)
+                val denominator = new BigDecimal(ratNum.denominator.bigInteger)
+                numerator.divide(denominator, ROUND_UP).setScale(0, RoundingMode.CEILING).intValue
+        }
+
+        private def isPositiveInfinity(Expr expr) {
+                expr.app && expr.getFuncDecl.name == infinitySymbol
+        }
+
+        private def isNegativeInfinity(Expr expr) {
+                // Negative infinity is represented as (* (- 1) oo)
+                if (!expr.app || expr.getFuncDecl.name != multSymbol || expr.numArgs != 2) {
+                        return false
+                }
+                isPositiveInfinity(expr.args.get(1))
+        }
+
+        private def prepareOptimize() {
+                val optimize = mkOptimize()
+                if (timeoutMilliseconds >= 0) {
+                        val params = mkParams()
+                        // We cannot turn TIMEOUT_SYMBOL_NAME into a Symbol in the constructor,
+                        // because there is no add(Symbol, int) overload.
+                        params.add(TIMEOUT_SYMBOL_NAME, timeoutMilliseconds)
+                        optimize.parameters = params
+                }
+                assertConstraints(optimize)
+                optimize
+        }
+
+        private def assertConstraints(Optimize it) {
+                for (pair : variables.entrySet) {
+                        assertBounds(pair.value, pair.key)
+                }
+                for (constraint : nonTrivialConstraints) {
+                        val expr = createLinearCombination(constraint.coefficients)
+                        assertBounds(expr, constraint)
+                }
+        }
+
+        private def assertBounds(Optimize it, ArithExpr expression, LinearBoundedExpression bounds) {
+                val lowerBound = bounds.lowerBound
+                val upperBound = bounds.upperBound
+                if (lowerBound == upperBound) {
+                        if (lowerBound === null) {
+                                return
+                        }
+                        Assert(mkEq(expression, mkInt(lowerBound)))
+                } else {
+                        if (lowerBound !== null) {
+                                Assert(mkGe(expression, mkInt(lowerBound)))
+                        }
+                        if (upperBound !== null) {
+                                Assert(mkLe(expression, mkInt(upperBound)))
+                        }
+                }
+        }
+
+        private def toExpr(LinearBoundedExpression linearBoundedExpression) {
+                switch (linearBoundedExpression) {
+                        Dimension: variables.get(linearBoundedExpression)
+                        LinearConstraint: createLinearCombination(linearBoundedExpression.coefficients)
+                        default: throw new IllegalArgumentException("Unknown linear bounded expression:" + linearBoundedExpression)
+                }
+        }
+
+        private def createLinearCombination(Map<Dimension, Integer> coefficients) {
+                val size = coefficients.size
+                if (size == 0) {
+                        return mkInt(0)
+                }
+                val array = newArrayOfSize(size)
+                var int i = 0
+                for (pair : coefficients.entrySet) {
+                        val variable = variables.get(pair.key)
+                        if (variable === null) {
+                                throw new IllegalArgumentException("Unknown dimension: " + pair.key.name)
+                        }
+                        val coefficient = pair.value
+                        val term = if (coefficient == 1) {
+                                        variable
+                                } else {
+                                        mkMul(mkInt(coefficient), variable)
+                                }
+                        array.set(i, term)
+                        i++
+                }
+                mkAdd(array)
+        }
+
+        override close() throws Exception {
+                context.close()
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Interval.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Interval.xtend
new file mode 100644
index 00000000..691c8783
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Interval.xtend
@@ -0,0 +1,584 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval
+
+import java.math.BigDecimal
+import java.math.MathContext
+import java.math.RoundingMode
+import org.eclipse.xtend.lib.annotations.Data
+
+abstract class Interval implements Comparable<Interval> {
+        static val PRECISION = 32
+        package static val ROUND_DOWN = new MathContext(PRECISION, RoundingMode.FLOOR)
+        package static val ROUND_UP = new MathContext(PRECISION, RoundingMode.CEILING)
+
+        private new() {
+        }
+
+        abstract def boolean mustEqual(Interval other)
+
+        abstract def boolean mayEqual(Interval other)
+
+        def mustNotEqual(Interval other) {
+                !mayEqual(other)
+        }
+
+        def mayNotEqual(Interval other) {
+                !mustEqual(other)
+        }
+
+        abstract def boolean mustBeLessThan(Interval other)
+
+        abstract def boolean mayBeLessThan(Interval other)
+
+        def mustBeLessThanOrEqual(Interval other) {
+                !mayBeGreaterThan(other)
+        }
+
+        def mayBeLessThanOrEqual(Interval other) {
+                !mustBeGreaterThan(other)
+        }
+
+        def mustBeGreaterThan(Interval other) {
+                other.mustBeLessThan(this)
+        }
+
+        def mayBeGreaterThan(Interval other) {
+                other.mayBeLessThan(this)
+        }
+
+        def mustBeGreaterThanOrEqual(Interval other) {
+                other.mustBeLessThanOrEqual(this)
+        }
+
+        def mayBeGreaterThanOrEqual(Interval other) {
+                other.mayBeLessThanOrEqual(this)
+        }
+
+        abstract def Interval min(Interval other)
+
+        abstract def Interval max(Interval other)
+
+        abstract def Interval join(Interval other)
+
+        def +() {
+                this
+        }
+
+        abstract def Interval -()
+
+        abstract def Interval +(Interval other)
+
+        abstract def Interval -(Interval other)
+
+        abstract def Interval *(int count)
+
+        abstract def Interval *(Interval other)
+
+        abstract def Interval /(Interval other)
+
+        abstract def Interval **(Interval other)
+
+        public static val EMPTY = new Interval {
+                override mustEqual(Interval other) {
+                        true
+                }
+
+                override mayEqual(Interval other) {
+                        false
+                }
+
+                override mustBeLessThan(Interval other) {
+                        true
+                }
+
+                override mayBeLessThan(Interval other) {
+                        false
+                }
+
+                override min(Interval other) {
+                        EMPTY
+                }
+
+                override max(Interval other) {
+                        EMPTY
+                }
+
+                override join(Interval other) {
+                        other
+                }
+
+                override -() {
+                        EMPTY
+                }
+
+                override +(Interval other) {
+                        EMPTY
+                }
+
+                override -(Interval other) {
+                        EMPTY
+                }
+
+                override *(int count) {
+                        EMPTY
+                }
+
+                override *(Interval other) {
+                        EMPTY
+                }
+
+                override /(Interval other) {
+                        EMPTY
+                }
+
+                override **(Interval other) {
+                        EMPTY
+                }
+
+                override toString() {
+                        "∅"
+                }
+
+                override compareTo(Interval o) {
+                        if (o == EMPTY) {
+                                0
+                        } else {
+                                -1
+                        }
+                }
+
+        }
+
+        public static val Interval ZERO = new NonEmpty(BigDecimal.ZERO, BigDecimal.ZERO)
+
+        public static val Interval UNBOUNDED = new NonEmpty(null, null)
+
+        static def Interval of(BigDecimal lower, BigDecimal upper) {
+                new NonEmpty(lower, upper)
+        }
+
+        static def between(double lower, double upper) {
+                of(new BigDecimal(lower, ROUND_DOWN), new BigDecimal(upper, ROUND_UP))
+        }
+
+        static def upTo(double upper) {
+                of(null, new BigDecimal(upper, ROUND_UP))
+        }
+
+        static def above(double lower) {
+                of(new BigDecimal(lower, ROUND_DOWN), null)
+        }
+
+        @Data
+        private static class NonEmpty extends Interval {
+                val BigDecimal lower
+                val BigDecimal upper
+
+                /**
+                 * Construct a new non-empty interval.
+                 * 
+                 * @param lower The lower bound of the interval. Use <code>null</code> for negative infinity.
+                 * @param upper The upper bound of the interval. Use <code>null</code> for positive infinity.
+                 */
+                new(BigDecimal lower, BigDecimal upper) {
+                        if (lower !== null && upper !== null && lower > upper) {
+                                throw new IllegalArgumentException("Lower bound of interval must not be larger than upper bound")
+                        }
+                        this.lower = lower
+                        this.upper = upper
+                }
+
+                override mustEqual(Interval other) {
+                        switch (other) {
+                                case EMPTY: true
+                                NonEmpty: lower == upper && lower == other.lower && lower == other.upper
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+
+                override mayEqual(Interval other) {
+                        if (other instanceof NonEmpty) {
+                                (lower === null || other.upper === null || lower <= other.upper) &&
+                                        (other.lower === null || upper === null || other.lower <= upper)
+                        } else {
+                                false
+                        }
+                }
+
+                override mustBeLessThan(Interval other) {
+                        switch (other) {
+                                case EMPTY: true
+                                NonEmpty: upper !== null && other.lower !== null && upper < other.lower
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+
+                override mayBeLessThan(Interval other) {
+                        if (other instanceof NonEmpty) {
+                                lower === null || other.upper === null || lower < other.upper
+                        } else {
+                                false
+                        }
+                }
+
+                override min(Interval other) {
+                        switch (other) {
+                                case EMPTY: this
+                                NonEmpty: min(other)
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+
+                def min(NonEmpty other) {
+                        new NonEmpty(
+                                lower.tryMin(other.lower),
+                                if(other.upper === null) upper else if(upper === null) other.upper else upper.min(other.upper)
+                        )
+                }
+
+                override max(Interval other) {
+                        switch (other) {
+                                case EMPTY: this
+                                NonEmpty: max(other)
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+
+                def max(NonEmpty other) {
+                        new NonEmpty(
+                                if(other.lower === null) lower else if(lower === null) other.lower else lower.max(other.lower),
+                                upper.tryMax(other.upper)
+                        )
+                }
+
+                override join(Interval other) {
+                        switch (other) {
+                                case EMPTY: this
+                                NonEmpty: new NonEmpty(lower.tryMin(other.lower), upper.tryMax(other.upper))
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+
+                override -() {
+                        new NonEmpty(upper?.negate(ROUND_DOWN), lower?.negate(ROUND_UP))
+                }
+
+                override +(Interval other) {
+                        switch (other) {
+                                case EMPTY: EMPTY
+                                NonEmpty: this + other
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+
+                def +(NonEmpty other) {
+                        new NonEmpty(
+                                lower.tryAdd(other.lower, ROUND_DOWN),
+                                upper.tryAdd(other.upper, ROUND_UP)
+                        )
+                }
+
+                private static def tryAdd(BigDecimal a, BigDecimal b, MathContext mc) {
+                        if (b === null) {
+                                null
+                        } else {
+                                a?.add(b, mc)
+                        }
+                }
+
+                override -(Interval other) {
+                        switch (other) {
+                                case EMPTY: EMPTY
+                                NonEmpty: this - other
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+
+                def -(NonEmpty other) {
+                        new NonEmpty(
+                                lower.trySubtract(other.upper, ROUND_DOWN),
+                                upper.trySubtract(other.lower, ROUND_UP)
+                        )
+                }
+
+                private static def trySubtract(BigDecimal a, BigDecimal b, MathContext mc) {
+                        if (b === null) {
+                                null
+                        } else {
+                                a?.subtract(b, mc)
+                        }
+                }
+
+                override *(int count) {
+                        val bigCount = new BigDecimal(count)
+                        new NonEmpty(
+                                lower.tryMultiply(bigCount, ROUND_DOWN),
+                                upper.tryMultiply(bigCount, ROUND_UP)
+                        )
+                }
+
+                override *(Interval other) {
+                        switch (other) {
+                                case EMPTY: EMPTY
+                                NonEmpty: this * other
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+
+                def *(NonEmpty other) {
+                        if (this == ZERO || other == ZERO) {
+                                ZERO
+                        } else if (nonpositive) {
+                                if (other.nonpositive) {
+                                        new NonEmpty(
+                                                upper.multiply(other.upper, ROUND_DOWN),
+                                                lower.tryMultiply(other.lower, ROUND_UP)
+                                        )
+                                } else if (other.nonnegative) {
+                                        new NonEmpty(
+                                                lower.tryMultiply(other.upper, ROUND_DOWN),
+                                                upper.multiply(other.lower, ROUND_UP)
+                                        )
+                                } else {
+                                        new NonEmpty(
+                                                lower.tryMultiply(other.upper, ROUND_DOWN),
+                                                lower.tryMultiply(other.lower, ROUND_UP)
+                                        )
+                                }
+                        } else if (nonnegative) {
+                                if (other.nonpositive) {
+                                        new NonEmpty(
+                                                upper.tryMultiply(other.lower, ROUND_DOWN),
+                                                lower.multiply(other.upper, ROUND_UP)
+                                        )
+                                } else if (other.nonnegative) {
+                                        new NonEmpty(
+                                                lower.multiply(other.lower, ROUND_DOWN),
+                                                upper.tryMultiply(other.upper, ROUND_UP)
+                                        )
+                                } else {
+                                        new NonEmpty(
+                                                upper.tryMultiply(other.lower, ROUND_DOWN),
+                                                upper.tryMultiply(other.upper, ROUND_UP)
+                                        )
+                                }
+                        } else {
+                                if (other.nonpositive) {
+                                        new NonEmpty(
+                                                upper.tryMultiply(other.lower, ROUND_DOWN),
+                                                lower.tryMultiply(other.lower, ROUND_UP)
+                                        )
+                                } else if (other.nonnegative) {
+                                        new NonEmpty(
+                                                lower.tryMultiply(other.upper, ROUND_DOWN),
+                                                upper.tryMultiply(other.upper, ROUND_UP)
+                                        )
+                                } else {
+                                        new NonEmpty(
+                                                lower.tryMultiply(other.upper, ROUND_DOWN).tryMin(upper.tryMultiply(other.lower, ROUND_DOWN)),
+                                                lower.tryMultiply(other.lower, ROUND_UP).tryMax(upper.tryMultiply(other.upper, ROUND_UP))
+                                        )
+                                }
+                        }
+                }
+
+                private def isNonpositive() {
+                        upper !== null && upper <= BigDecimal.ZERO
+                }
+
+                private def isNonnegative() {
+                        lower !== null && lower >= BigDecimal.ZERO
+                }
+
+                private static def tryMultiply(BigDecimal a, BigDecimal b, MathContext mc) {
+                        if (b === null) {
+                                null
+                        } else {
+                                a?.multiply(b, mc)
+                        }
+                }
+
+                private static def tryMin(BigDecimal a, BigDecimal b) {
+                        if (b === null) {
+                                null
+                        } else {
+                                a?.min(b)
+                        }
+                }
+
+                private static def tryMax(BigDecimal a, BigDecimal b) {
+                        if (b === null) {
+                                null
+                        } else {
+                                a?.max(b)
+                        }
+                }
+
+                override /(Interval other) {
+                        switch (other) {
+                                case EMPTY: EMPTY
+                                NonEmpty: this / other
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+
+                def /(NonEmpty other) {
+                        if (other == ZERO) {
+                                EMPTY
+                        } else if (this == ZERO) {
+                                ZERO
+                        } else if (other.strictlyNegative) {
+                                if (nonpositive) {
+                                        new NonEmpty(
+                                                upper.tryDivide(other.lower, ROUND_DOWN),
+                                                lower.tryDivide(other.upper, ROUND_UP)
+                                        )
+                                } else if (nonnegative) {
+                                        new NonEmpty(
+                                                upper.tryDivide(other.upper, ROUND_DOWN),
+                                                lower.tryDivide(other.lower, ROUND_UP)
+                                        )
+                                } else { // lower < 0 < upper
+                                        new NonEmpty(
+                                                upper.tryDivide(other.upper, ROUND_DOWN),
+                                                lower.tryDivide(other.upper, ROUND_UP)
+                                        )
+                                }
+                        } else if (other.strictlyPositive) {
+                                if (nonpositive) {
+                                        new NonEmpty(
+                                                lower.tryDivide(other.lower, ROUND_DOWN),
+                                                upper.tryDivide(other.upper, ROUND_UP)
+                                        )
+                                } else if (nonnegative) {
+                                        new NonEmpty(
+                                                lower.tryDivide(other.upper, ROUND_DOWN),
+                                                upper.tryDivide(other.lower, ROUND_UP)
+                                        )
+                                } else { // lower < 0 < upper
+                                        new NonEmpty(
+                                                lower.tryDivide(other.lower, ROUND_DOWN),
+                                                upper.tryDivide(other.lower, ROUND_UP)
+                                        )
+                                }
+                        } else { // other contains 0
+                                if (other.lower == BigDecimal.ZERO) { // 0 == other.lower < other.upper, because [0, 0] was exluded earlier
+                                        if (nonpositive) {
+                                                new NonEmpty(null, upper.tryDivide(other.upper, ROUND_UP))
+                                        } else if (nonnegative) {
+                                                new NonEmpty(lower.tryDivide(other.upper, ROUND_DOWN), null)
+                                        } else { // lower < 0 < upper
+                                                UNBOUNDED
+                                        }
+                                } else if (other.upper == BigDecimal.ZERO) { // other.lower < other.upper == 0
+                                        if (nonpositive) {
+                                                new NonEmpty(upper.tryDivide(other.lower, ROUND_DOWN), null)
+                                        } else if (nonnegative) {
+                                                new NonEmpty(null, lower.tryDivide(other.lower, ROUND_UP))
+                                        } else { // lower < 0 < upper
+                                                UNBOUNDED
+                                        }
+                                } else { // other.lower < 0 < other.upper
+                                        UNBOUNDED
+                                }
+                        }
+                }
+
+                private def isStrictlyNegative() {
+                        upper !== null && upper < BigDecimal.ZERO
+                }
+
+                private def isStrictlyPositive() {
+                        lower !== null && lower > BigDecimal.ZERO
+                }
+
+                private static def tryDivide(BigDecimal a, BigDecimal b, MathContext mc) {
+                        if (b === null) {
+                                BigDecimal.ZERO
+                        } else {
+                                a?.divide(b, mc)
+                        }
+                }
+
+                override **(Interval other) {
+                        switch (other) {
+                                case EMPTY: EMPTY
+                                NonEmpty: this ** other
+                                default: throw new IllegalArgumentException("Unknown interval: " + other)
+                        }
+                }
+
+                def **(NonEmpty other) {
+                        // XXX This should use proper rounding for log and exp instead of
+                        // converting to double.
+                        // XXX We should not ignore (integer) powers of negative numbers.
+                        val lowerLog = if (lower === null || lower <= BigDecimal.ZERO) {
+                                        null
+                                } else {
+                                        new BigDecimal(Math.log(lower.doubleValue), ROUND_DOWN)
+                                }
+                        val upperLog = if (upper === null) {
+                                        null
+                                } else if (upper == BigDecimal.ZERO) {
+                                        return ZERO
+                                } else if (upper < BigDecimal.ZERO) {
+                                        return EMPTY
+                                } else {
+                                        new BigDecimal(Math.log(upper.doubleValue), ROUND_UP)
+                                }
+                        val log = new NonEmpty(lowerLog, upperLog)
+                        val product = log * other
+                        if (product instanceof NonEmpty) {
+                                val lowerResult = if (product.lower === null) {
+                                                BigDecimal.ZERO
+                                        } else {
+                                                new BigDecimal(Math.exp(product.lower.doubleValue), ROUND_DOWN)
+                                        }
+                                val upperResult = if (product.upper === null) {
+                                                null
+                                        } else {
+                                                new BigDecimal(Math.exp(product.upper.doubleValue), ROUND_UP)
+                                        }
+                                new NonEmpty(lowerResult, upperResult)
+                        } else {
+                                throw new IllegalArgumentException("Unknown interval: " + product)
+                        }
+                }
+
+                override toString() {
+                        '''«IF lower === null»(-∞«ELSE»[«lower»«ENDIF», «IF upper === null»∞)«ELSE»«upper»]«ENDIF»'''
+                }
+
+                override compareTo(Interval o) {
+                        switch (o) {
+                                case EMPTY: 1
+                                NonEmpty: compareTo(o)
+                                default: throw new IllegalArgumentException("Unknown interval: " + o)
+                        }
+                }
+
+                def compareTo(NonEmpty o) {
+                        if (lower === null) {
+                                if (o.lower !== null) {
+                                        return -1
+                                }
+                        } else if (o.lower === null) { // lower !== null
+                                return 1
+                        } else { // both lower and o.lower are finite
+                                val lowerDifference = lower.compareTo(o.lower)
+                                if (lowerDifference != 0) {
+                                        return lowerDifference
+                                }
+                        }
+                        if (upper === null) {
+                                if (o.upper === null) {
+                                        return 0
+                                } else {
+                                        return 1
+                                }
+                        } else if (o.upper === null) { // upper !== null
+                                return -1
+                        }
+                        upper.compareTo(o.upper)
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationMode.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationMode.java
new file mode 100644
index 00000000..f106e305
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationMode.java
@@ -0,0 +1,99 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval;
+
+import java.util.function.BinaryOperator;
+
+public enum IntervalAggregationMode implements BinaryOperator<Interval> {
+        SUM("intervalSum", "Sum a set of intervals") {
+                @Override
+                public IntervalRedBlackNode createNode(Interval interval) {
+                        return new IntervalRedBlackNode(interval) {
+                                public boolean isMultiplicitySensitive() {
+                                        return true;
+                                }
+
+                                public Interval multiply(Interval interval, int count) {
+                                        return interval.operator_multiply(count);
+                                };
+
+                                @Override
+                                public Interval op(Interval left, Interval right) {
+                                        return left.operator_plus(right);
+                                }
+                        };
+                }
+                
+                @Override
+                public Interval getNeutral() {
+                        return Interval.ZERO;
+                }
+        },
+        
+        MIN("intervalMin", "Find the minimum a set of intervals") {
+                @Override
+                public IntervalRedBlackNode createNode(Interval interval) {
+                        return new IntervalRedBlackNode(interval) {
+                                @Override
+                                public Interval op(Interval left, Interval right) {
+                                        return left.min(right);
+                                }
+                        };
+                }
+        },
+        
+        MAX("intervalMax", "Find the maximum a set of intervals") {
+                @Override
+                public IntervalRedBlackNode createNode(Interval interval) {
+                        return new IntervalRedBlackNode(interval) {
+                                @Override
+                                public Interval op(Interval left, Interval right) {
+                                        return left.max(right);
+                                }
+                        };
+                }
+        },
+
+        JOIN("intervalJoin", "Calculate the smallest interval containing all the intervals in a set") {
+                @Override
+                public IntervalRedBlackNode createNode(Interval interval) {
+                        return new IntervalRedBlackNode(interval) {
+                                @Override
+                                public Interval op(Interval left, Interval right) {
+                                        return left.join(right);
+                                }
+                        };
+                }
+        };
+
+        private final String modeName;
+        private final String description;
+        private final IntervalRedBlackNode empty;
+
+        IntervalAggregationMode(String modeName, String description) {
+                this.modeName = modeName;
+                this.description = description;
+                empty = createNode(null);
+        }
+
+        public String getModeName() {
+                return modeName;
+        }
+
+        public String getDescription() {
+                return description;
+        }
+
+        public IntervalRedBlackNode getEmpty() {
+                return empty;
+        }
+
+        @Override
+        public Interval apply(Interval left, Interval right) {
+                return empty.op(left, right);
+        }
+
+        public abstract IntervalRedBlackNode createNode(Interval interval);
+        
+        public Interval getNeutral() {
+                return Interval.EMPTY;
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationOperator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationOperator.xtend
new file mode 100644
index 00000000..21d3d73b
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalAggregationOperator.xtend
@@ -0,0 +1,48 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval
+
+import java.util.stream.Stream
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+@FinalFieldsConstructor
+class IntervalAggregationOperator implements IMultisetAggregationOperator<Interval, IntervalRedBlackNode, Interval> {
+        @Accessors val IntervalAggregationMode mode
+
+        override getName() {
+                mode.modeName
+        }
+
+        override getShortDescription() {
+                mode.description
+        }
+
+        override createNeutral() {
+                mode.empty
+        }
+
+        override isNeutral(IntervalRedBlackNode result) {
+                result.leaf
+        }
+
+        override update(IntervalRedBlackNode oldResult, Interval updateValue, boolean isInsertion) {
+                if (isInsertion) {
+                        val newNode = mode.createNode(updateValue)
+                        oldResult.add(newNode)
+                } else {
+                        oldResult.remove(updateValue)
+                }
+        }
+
+        override getAggregate(IntervalRedBlackNode result) {
+                if (result.leaf) {
+                        mode.neutral
+                } else {
+                        result.result
+                }
+        }
+
+        override aggregateStream(Stream<Interval> stream) {
+                stream.reduce(mode).orElse(mode.neutral)
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalHullAggregatorOperator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalHullAggregatorOperator.xtend
new file mode 100644
index 00000000..ce48eca1
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalHullAggregatorOperator.xtend
@@ -0,0 +1,87 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval
+
+import java.math.BigDecimal
+import java.math.MathContext
+import java.util.SortedMap
+import java.util.TreeMap
+import java.util.stream.Stream
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator
+
+abstract class IntervalHullAggregatorOperator<T extends Comparable<T>> implements IMultisetAggregationOperator<T, SortedMap<T, Integer>, Interval> {
+        protected new() {
+        }
+        
+        override getName() {
+                "intervalHull"
+        }
+
+        override getShortDescription() {
+                "Calculates the interval hull of a set of numbers"
+        }
+
+        override createNeutral() {
+                new TreeMap
+        }
+
+        override getAggregate(SortedMap<T, Integer> result) {
+                if (result.neutral) {
+                        Interval.EMPTY
+                } else {
+                        toInterval(result.firstKey, result.lastKey)
+                }
+        }
+        
+        protected abstract def BigDecimal toBigDecimal(T value, MathContext mc)
+        
+        private def toInterval(T min, T max) {
+                Interval.of(min.toBigDecimal(Interval.ROUND_DOWN), max.toBigDecimal(Interval.ROUND_UP))
+        }
+
+        override isNeutral(SortedMap<T, Integer> result) {
+                result.empty
+        }
+
+        override update(SortedMap<T, Integer> oldResult, T updateValue, boolean isInsertion) {
+                if (isInsertion) {
+                        oldResult.compute(updateValue) [ key, value |
+                                if (value === null) {
+                                        1
+                                } else if (value > 0) {
+                                        value + 1
+                                } else {
+                                        throw new IllegalStateException("Invalid count: " + value)
+                                }
+                        ]
+                } else {
+                        oldResult.compute(updateValue) [ key, value |
+                                if (value === 1) {
+                                        null
+                                } else if (value > 1) {
+                                        value - 1
+                                } else {
+                                        throw new IllegalStateException("Invalid count: " + value)
+                                }
+                        ]
+                }
+                oldResult
+        }
+
+        override aggregateStream(Stream<T> stream) {
+                val iterator = stream.iterator
+                if (!iterator.hasNext) {
+                        return Interval.EMPTY
+                }
+                var min = iterator.next
+                var max = min
+                while (iterator.hasNext) {
+                        val element = iterator.next
+                        if (element.compareTo(min) < 0) {
+                                min = element
+                        }
+                        if (element.compareTo(max) > 0) {
+                                max = element
+                        }
+                }
+                toInterval(min, max)
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalRedBlackNode.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalRedBlackNode.xtend
new file mode 100644
index 00000000..3aa575bc
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/IntervalRedBlackNode.xtend
@@ -0,0 +1,177 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval
+
+abstract class IntervalRedBlackNode extends RedBlackNode<IntervalRedBlackNode> {
+        public val Interval interval
+        public var int count = 1
+        public var Interval result
+
+        new(Interval interval) {
+                this.interval = interval
+        }
+
+        def boolean isMultiplicitySensitive() {
+                false
+        }
+
+        def Interval multiply(Interval interval, int count) {
+                interval
+        }
+
+        abstract def Interval op(Interval left, Interval right)
+
+        override augment() {
+                val value = calcualteAugmentation()
+                if (result == value) {
+                        false
+                } else {
+                        result = value
+                        true
+                }
+        }
+
+        private def calcualteAugmentation() {
+                var value = multiply(interval, count)
+                if (!left.leaf) {
+                        value = op(value, left.result)
+                }
+                if (!right.leaf) {
+                        value = op(value, right.result)
+                }
+                value
+        }
+
+        override assertNodeIsValid() {
+                super.assertNodeIsValid()
+                if (leaf) {
+                        return
+                }
+                if (count <= 0) {
+                        throw new IllegalStateException("Node with nonpositive count")
+                }
+                val value = calcualteAugmentation()
+                if (result != value) {
+                        throw new IllegalStateException("Node with invalid augmentation: " + result + " != " + value)
+                }
+        }
+
+        override assertSubtreeIsValid() {
+                super.assertSubtreeIsValid()
+                assertNodeIsValid()
+        }
+
+        override compareTo(IntervalRedBlackNode other) {
+                if (leaf || other.leaf) {
+                        throw new IllegalArgumentException("One of the nodes is a leaf node")
+                }
+                interval.compareTo(other.interval)
+        }
+
+        def add(IntervalRedBlackNode newNode) {
+                if (parent !== null) {
+                        throw new IllegalArgumentException("This is not the root of a tree")
+                }
+                if (leaf) {
+                        newNode.isRed = false
+                        newNode.left = this
+                        newNode.right = this
+                        newNode.parent = null
+                        newNode.augment
+                        return newNode
+                }
+                val modifiedNode = addWithoutFixup(newNode)
+                if (modifiedNode === newNode) {
+                        // Must augment here, because fixInsertion() might call augment()
+                        // on a node repeatedly, which might lose the change notification the
+                        // second time it is called, and the augmentation will fail to
+                        // reach the root.
+                        modifiedNode.augmentRecursively
+                        modifiedNode.isRed = true
+                        return modifiedNode.fixInsertion
+                }
+                if (multiplicitySensitive) {
+                        modifiedNode.augmentRecursively
+                }
+                this
+        }
+
+        private def addWithoutFixup(IntervalRedBlackNode newNode) {
+                var node = this
+                while (!node.leaf) {
+                        val comparison = node.interval.compareTo(newNode.interval)
+                        if (comparison < 0) {
+                                if (node.left.leaf) {
+                                        newNode.left = node.left
+                                        newNode.right = node.left
+                                        node.left = newNode
+                                        newNode.parent = node
+                                        return newNode
+                                } else {
+                                        node = node.left
+                                }
+                        } else if (comparison > 0) {
+                                if (node.right.leaf) {
+                                        newNode.left = node.right
+                                        newNode.right = node.right
+                                        node.right = newNode
+                                        newNode.parent = node
+                                        return newNode
+                                } else {
+                                        node = node.right
+                                }
+                        } else { // comparison == 0
+                                newNode.parent = null
+                                node.count++
+                                return node
+                        }
+                }
+                throw new IllegalStateException("Reached leaf node while searching for insertion point")
+        }
+
+        private def augmentRecursively() {
+                for (var node = this; node !== null; node = node.parent) {
+                        if (!node.augment) {
+                                return
+                        }
+                }
+        }
+
+        def remove(Interval interval) {
+                val node = find(interval)
+                node.count--
+                if (node.count == 0) {
+                        return node.remove
+                }
+                if (multiplicitySensitive) {
+                        node.augmentRecursively
+                }
+                this
+        }
+
+        private def find(Interval interval) {
+                var node = this
+                while (!node.leaf) {
+                        val comparison = node.interval.compareTo(interval)
+                        if (comparison < 0) {
+                                node = node.left
+                        } else if (comparison > 0) {
+                                node = node.right
+                        } else { // comparison == 0
+                                return node
+                        }
+                }
+                throw new IllegalStateException("Reached leaf node while searching for interval to remove")
+        }
+
+        override toString() {
+                if (leaf) {
+                        "L"
+                } else {
+                        '''
+                                «IF isRed»R«ELSE»B«ENDIF» «count»«interval» : «result»
+                                        «left»
+                                        «right»
+                        '''
+                }
+        }
+
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/RedBlackNode.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/RedBlackNode.java
new file mode 100644
index 00000000..8c40816b
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/RedBlackNode.java
@@ -0,0 +1,1392 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 btrekkie
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval;
+
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+/**
+ * A node in a red-black tree ( https://en.wikipedia.org/wiki/Red%E2%80%93black_tree ). Compared to a class like Java's
+ * TreeMap, RedBlackNode is a low-level data structure. The internals of a node are exposed as public fields, allowing
+ * clients to directly observe and manipulate the structure of the tree. This gives clients flexibility, although it
+ * also enables them to violate the red-black or BST properties. The RedBlackNode class provides methods for performing
+ * various standard operations, such as insertion and removal.
+ *
+ * Unlike most implementations of binary search trees, RedBlackNode supports arbitrary augmentation. By subclassing
+ * RedBlackNode, clients can add arbitrary data and augmentation information to each node. For example, if we were to
+ * use a RedBlackNode subclass to implement a sorted set, the subclass would have a field storing an element in the set.
+ * If we wanted to keep track of the number of non-leaf nodes in each subtree, we would store this as a "size" field and
+ * override augment() to update this field. All RedBlackNode methods (such as "insert" and remove()) call augment() as
+ * necessary to correctly maintain the augmentation information, unless otherwise indicated.
+ *
+ * The values of the tree are stored in the non-leaf nodes. RedBlackNode does not support use cases where values must be
+ * stored in the leaf nodes. It is recommended that all of the leaf nodes in a given tree be the same (black)
+ * RedBlackNode instance, to save space. The root of an empty tree is a leaf node, as opposed to null.
+ *
+ * For reference, a red-black tree is a binary search tree satisfying the following properties:
+ *
+ * - Every node is colored red or black.
+ * - The leaf nodes, which are dummy nodes that do not store any values, are colored black.
+ * - The root is black.
+ * - Both children of each red node are black.
+ * - Every path from the root to a leaf contains the same number of black nodes.
+ *
+ * @param <N> The type of node in the tree. For example, we might have
+ *     "class FooNode<T> extends RedBlackNode<FooNode<T>>".
+ * @author Bill Jacobs
+ */
+public abstract class RedBlackNode<N extends RedBlackNode<N>> implements Comparable<N> {
+    /** A Comparator that compares Comparable elements using their natural order. */
+    private static final Comparator<Comparable<Object>> NATURAL_ORDER = new Comparator<Comparable<Object>>() {
+        @Override
+        public int compare(Comparable<Object> value1, Comparable<Object> value2) {
+            return value1.compareTo(value2);
+        }
+    };
+
+    /** The parent of this node, if any.  "parent" is null if this is a leaf node. */
+    public N parent;
+
+    /** The left child of this node.  "left" is null if this is a leaf node. */
+    public N left;
+
+    /** The right child of this node.  "right" is null if this is a leaf node. */
+    public N right;
+
+    /** Whether the node is colored red, as opposed to black. */
+    public boolean isRed;
+
+    /**
+     * Sets any augmentation information about the subtree rooted at this node that is stored in this node.  For
+     * example, if we augment each node by subtree size (the number of non-leaf nodes in the subtree), this method would
+     * set the size field of this node to be equal to the size field of the left child plus the size field of the right
+     * child plus one.
+     *
+     * "Augmentation information" is information that we can compute about a subtree rooted at some node, preferably
+     * based only on the augmentation information in the node's two children and the information in the node.  Examples
+     * of augmentation information are the sum of the values in a subtree and the number of non-leaf nodes in a subtree.
+     * Augmentation information may not depend on the colors of the nodes.
+     *
+     * This method returns whether the augmentation information in any of the ancestors of this node might have been
+     * affected by changes in this subtree since the last call to augment().  In the usual case, where the augmentation
+     * information depends only on the information in this node and the augmentation information in its immediate
+     * children, this is equivalent to whether the augmentation information changed as a result of this call to
+     * augment().  For example, in the case of subtree size, this returns whether the value of the size field prior to
+     * calling augment() differed from the size field of the left child plus the size field of the right child plus one.
+     * False positives are permitted.  The return value is unspecified if we have not called augment() on this node
+     * before.
+     *
+     * This method may assume that this is not a leaf node.  It may not assume that the augmentation information stored
+     * in any of the tree's nodes is correct.  However, if the augmentation information stored in all of the node's
+     * descendants is correct, then the augmentation information stored in this node must be correct after calling
+     * augment().
+     */
+    public boolean augment() {
+        return false;
+    }
+
+    /**
+     * Throws a RuntimeException if we detect that this node locally violates any invariants specific to this subclass
+     * of RedBlackNode.  For example, if this stores the size of the subtree rooted at this node, this should throw a
+     * RuntimeException if the size field of this is not equal to the size field of the left child plus the size field
+     * of the right child plus one.  Note that we may call this on a leaf node.
+     *
+     * assertSubtreeIsValid() calls assertNodeIsValid() on each node, or at least starts to do so until it detects a
+     * problem.  assertNodeIsValid() should assume the node is in a tree that satisfies all properties common to all
+     * red-black trees, as assertSubtreeIsValid() is responsible for such checks.  assertNodeIsValid() should be
+     * "downward-looking", i.e. it should ignore any information in "parent", and it should be "local", i.e. it should
+     * only check a constant number of descendants.  To include "global" checks, such as verifying the BST property
+     * concerning ordering, override assertSubtreeIsValid().  assertOrderIsValid is useful for checking the BST
+     * property.
+     */
+    public void assertNodeIsValid() {
+
+    }
+
+    /** Returns whether this is a leaf node. */
+    public boolean isLeaf() {
+        return left == null;
+    }
+
+    /** Returns the root of the tree that contains this node. */
+    public N root() {
+        @SuppressWarnings("unchecked")
+        N node = (N)this;
+        while (node.parent != null) {
+            node = node.parent;
+        }
+        return node;
+    }
+
+    /** Returns the first node in the subtree rooted at this node, if any. */
+    public N min() {
+        if (isLeaf()) {
+            return null;
+        }
+        @SuppressWarnings("unchecked")
+        N node = (N)this;
+        while (!node.left.isLeaf()) {
+            node = node.left;
+        }
+        return node;
+    }
+
+    /** Returns the last node in the subtree rooted at this node, if any. */
+    public N max() {
+        if (isLeaf()) {
+            return null;
+        }
+        @SuppressWarnings("unchecked")
+        N node = (N)this;
+        while (!node.right.isLeaf()) {
+            node = node.right;
+        }
+        return node;
+    }
+
+    /** Returns the node immediately before this in the tree that contains this node, if any. */
+    public N predecessor() {
+        if (!left.isLeaf()) {
+            N node;
+            for (node = left; !node.right.isLeaf(); node = node.right);
+            return node;
+        } else if (parent == null) {
+            return null;
+        } else {
+            @SuppressWarnings("unchecked")
+            N node = (N)this;
+            while (node.parent != null && node.parent.left == node) {
+                node = node.parent;
+            }
+            return node.parent;
+        }
+    }
+
+    /** Returns the node immediately after this in the tree that contains this node, if any. */
+    public N successor() {
+        if (!right.isLeaf()) {
+            N node;
+            for (node = right; !node.left.isLeaf(); node = node.left);
+            return node;
+        } else if (parent == null) {
+            return null;
+        } else {
+            @SuppressWarnings("unchecked")
+            N node = (N)this;
+            while (node.parent != null && node.parent.right == node) {
+                node = node.parent;
+            }
+            return node.parent;
+        }
+    }
+
+    /**
+     * Performs a left rotation about this node. This method assumes that !isLeaf() && !right.isLeaf(). It calls
+     * augment() on this node and on its resulting parent. However, it does not call augment() on any of the resulting
+     * parent's ancestors, because that is normally the responsibility of the caller.
+     * @return The return value from calling augment() on the resulting parent.
+     */
+    public boolean rotateLeft() {
+        if (isLeaf() || right.isLeaf()) {
+            throw new IllegalArgumentException("The node or its right child is a leaf");
+        }
+        N newParent = right;
+        right = newParent.left;
+        @SuppressWarnings("unchecked")
+        N nThis = (N)this;
+        if (!right.isLeaf()) {
+            right.parent = nThis;
+        }
+        newParent.parent = parent;
+        parent = newParent;
+        newParent.left = nThis;
+        if (newParent.parent != null) {
+            if (newParent.parent.left == this) {
+                newParent.parent.left = newParent;
+            } else {
+                newParent.parent.right = newParent;
+            }
+        }
+        augment();
+        return newParent.augment();
+    }
+
+    /**
+     * Performs a right rotation about this node. This method assumes that !isLeaf() && !left.isLeaf(). It calls
+     * augment() on this node and on its resulting parent. However, it does not call augment() on any of the resulting
+     * parent's ancestors, because that is normally the responsibility of the caller.
+     * @return The return value from calling augment() on the resulting parent.
+     */
+    public boolean rotateRight() {
+        if (isLeaf() || left.isLeaf()) {
+            throw new IllegalArgumentException("The node or its left child is a leaf");
+        }
+        N newParent = left;
+        left = newParent.right;
+        @SuppressWarnings("unchecked")
+        N nThis = (N)this;
+        if (!left.isLeaf()) {
+            left.parent = nThis;
+        }
+        newParent.parent = parent;
+        parent = newParent;
+        newParent.right = nThis;
+        if (newParent.parent != null) {
+            if (newParent.parent.left == this) {
+                newParent.parent.left = newParent;
+            } else {
+                newParent.parent.right = newParent;
+            }
+        }
+        augment();
+        return newParent.augment();
+    }
+
+    /**
+     * Performs red-black insertion fixup.  To be more precise, this fixes a tree that satisfies all of the requirements
+     * of red-black trees, except that this may be a red child of a red node, and if this is the root, the root may be
+     * red.  node.isRed must initially be true.  This method assumes that this is not a leaf node.  The method performs
+     * any rotations by calling rotateLeft() and rotateRight().  This method is more efficient than fixInsertion if
+     * "augment" is false or augment() might return false.
+     * @param augment Whether to set the augmentation information for "node" and its ancestors, by calling augment().
+     */
+    public void fixInsertionWithoutGettingRoot(boolean augment) {
+        if (!isRed) {
+            throw new IllegalArgumentException("The node must be red");
+        }
+        boolean changed = augment;
+        if (augment) {
+            augment();
+        }
+
+        RedBlackNode<N> node = this;
+        while (node.parent != null && node.parent.isRed) {
+            N parent = node.parent;
+            N grandparent = parent.parent;
+            if (grandparent.left.isRed && grandparent.right.isRed) {
+                grandparent.left.isRed = false;
+                grandparent.right.isRed = false;
+                grandparent.isRed = true;
+
+                if (changed) {
+                    changed = parent.augment();
+                    if (changed) {
+                        changed = grandparent.augment();
+                    }
+                }
+                node = grandparent;
+            } else {
+                if (parent.left == node) {
+                    if (grandparent.right == parent) {
+                        parent.rotateRight();
+                        node = parent;
+                        parent = node.parent;
+                    }
+                } else if (grandparent.left == parent) {
+                    parent.rotateLeft();
+                    node = parent;
+                    parent = node.parent;
+                }
+
+                if (parent.left == node) {
+                    boolean grandparentChanged = grandparent.rotateRight();
+                    if (augment) {
+                        changed = grandparentChanged;
+                    }
+                } else {
+                    boolean grandparentChanged = grandparent.rotateLeft();
+                    if (augment) {
+                        changed = grandparentChanged;
+                    }
+                }
+
+                parent.isRed = false;
+                grandparent.isRed = true;
+                node = parent;
+                break;
+            }
+        }
+
+        if (node.parent == null) {
+            node.isRed = false;
+        }
+        if (changed) {
+            for (node = node.parent; node != null; node = node.parent) {
+                if (!node.augment()) {
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Performs red-black insertion fixup.  To be more precise, this fixes a tree that satisfies all of the requirements
+     * of red-black trees, except that this may be a red child of a red node, and if this is the root, the root may be
+     * red.  node.isRed must initially be true.  This method assumes that this is not a leaf node.  The method performs
+     * any rotations by calling rotateLeft() and rotateRight().  This method is more efficient than fixInsertion() if
+     * augment() might return false.
+     */
+    public void fixInsertionWithoutGettingRoot() {
+        fixInsertionWithoutGettingRoot(true);
+    }
+
+    /**
+     * Performs red-black insertion fixup.  To be more precise, this fixes a tree that satisfies all of the requirements
+     * of red-black trees, except that this may be a red child of a red node, and if this is the root, the root may be
+     * red.  node.isRed must initially be true.  This method assumes that this is not a leaf node.  The method performs
+     * any rotations by calling rotateLeft() and rotateRight().
+     * @param augment Whether to set the augmentation information for "node" and its ancestors, by calling augment().
+     * @return The root of the resulting tree.
+     */
+    public N fixInsertion(boolean augment) {
+        fixInsertionWithoutGettingRoot(augment);
+        return root();
+    }
+
+    /**
+     * Performs red-black insertion fixup.  To be more precise, this fixes a tree that satisfies all of the requirements
+     * of red-black trees, except that this may be a red child of a red node, and if this is the root, the root may be
+     * red.  node.isRed must initially be true.  This method assumes that this is not a leaf node.  The method performs
+     * any rotations by calling rotateLeft() and rotateRight().
+     * @return The root of the resulting tree.
+     */
+    public N fixInsertion() {
+        fixInsertionWithoutGettingRoot(true);
+        return root();
+    }
+
+    /** Returns a Comparator that compares instances of N using their natural order, as in N.compareTo. */
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    private Comparator<N> naturalOrder() {
+        Comparator comparator = (Comparator)NATURAL_ORDER;
+        return (Comparator<N>)comparator;
+    }
+
+    /**
+     * Inserts the specified node into the tree rooted at this node. Assumes this is the root. We treat newNode as a
+     * solitary node that does not belong to any tree, and we ignore its initial "parent", "left", "right", and isRed
+     * fields.
+     *
+     * If it is not efficient or convenient to find the location for a node using a Comparator, then you should manually
+     * add the node to the appropriate location, color it red, and call fixInsertion().
+     *
+     * @param newNode The node to insert.
+     * @param allowDuplicates Whether to insert newNode if there is an equal node in the tree. To check whether we
+     *     inserted newNode, check whether newNode.parent is null and the return value differs from newNode.
+     * @param comparator A comparator indicating where to put the node. If this is null, we use the nodes' natural
+     *     order, as in N.compareTo. If you are passing null, then you must override the compareTo method, because the
+     *     default implementation requires the nodes to already be in the same tree.
+     * @return The root of the resulting tree.
+     */
+    public N insert(N newNode, boolean allowDuplicates, Comparator<? super N> comparator) {
+        if (parent != null) {
+            throw new IllegalArgumentException("This is not the root of a tree");
+        }
+        @SuppressWarnings("unchecked")
+        N nThis = (N)this;
+        if (isLeaf()) {
+            newNode.isRed = false;
+            newNode.left = nThis;
+            newNode.right = nThis;
+            newNode.parent = null;
+            newNode.augment();
+            return newNode;
+        }
+        if (comparator == null) {
+            comparator = naturalOrder();
+        }
+
+        N node = nThis;
+        int comparison;
+        while (true) {
+            comparison = comparator.compare(newNode, node);
+            if (comparison < 0) {
+                if (!node.left.isLeaf()) {
+                    node = node.left;
+                } else {
+                    newNode.left = node.left;
+                    newNode.right = node.left;
+                    node.left = newNode;
+                    newNode.parent = node;
+                    break;
+                }
+            } else if (comparison > 0 || allowDuplicates) {
+                if (!node.right.isLeaf()) {
+                    node = node.right;
+                } else {
+                    newNode.left = node.right;
+                    newNode.right = node.right;
+                    node.right = newNode;
+                    newNode.parent = node;
+                    break;
+                }
+            } else {
+                newNode.parent = null;
+                return nThis;
+            }
+        }
+        newNode.isRed = true;
+        return newNode.fixInsertion();
+    }
+
+    /**
+     * Moves this node to its successor's former position in the tree and vice versa, i.e. sets the "left", "right",
+     * "parent", and isRed fields of each.  This method assumes that this is not a leaf node.
+     * @return The node with which we swapped.
+     */
+    private N swapWithSuccessor() {
+        N replacement = successor();
+        boolean oldReplacementIsRed = replacement.isRed;
+        N oldReplacementLeft = replacement.left;
+        N oldReplacementRight = replacement.right;
+        N oldReplacementParent = replacement.parent;
+
+        replacement.isRed = isRed;
+        replacement.left = left;
+        replacement.right = right;
+        replacement.parent = parent;
+        if (parent != null) {
+            if (parent.left == this) {
+                parent.left = replacement;
+            } else {
+                parent.right = replacement;
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        N nThis = (N)this;
+        isRed = oldReplacementIsRed;
+        left = oldReplacementLeft;
+        right = oldReplacementRight;
+        if (oldReplacementParent == this) {
+            parent = replacement;
+            parent.right = nThis;
+        } else {
+            parent = oldReplacementParent;
+            parent.left = nThis;
+        }
+
+        replacement.right.parent = replacement;
+        if (!replacement.left.isLeaf()) {
+            replacement.left.parent = replacement;
+        }
+        if (!right.isLeaf()) {
+            right.parent = nThis;
+        }
+        return replacement;
+    }
+
+    /**
+     * Performs red-black deletion fixup.  To be more precise, this fixes a tree that satisfies all of the requirements
+     * of red-black trees, except that all paths from the root to a leaf that pass through the sibling of this node have
+     * one fewer black node than all other root-to-leaf paths.  This method assumes that this is not a leaf node.
+     */
+    private void fixSiblingDeletion() {
+        RedBlackNode<N> sibling = this;
+        boolean changed = true;
+        boolean haveAugmentedParent = false;
+        boolean haveAugmentedGrandparent = false;
+        while (true) {
+            N parent = sibling.parent;
+            if (sibling.isRed) {
+                parent.isRed = true;
+                sibling.isRed = false;
+                if (parent.left == sibling) {
+                    changed = parent.rotateRight();
+                    sibling = parent.left;
+                } else {
+                    changed = parent.rotateLeft();
+                    sibling = parent.right;
+                }
+                haveAugmentedParent = true;
+                haveAugmentedGrandparent = true;
+            } else if (!sibling.left.isRed && !sibling.right.isRed) {
+                sibling.isRed = true;
+                if (parent.isRed) {
+                    parent.isRed = false;
+                    break;
+                } else {
+                    if (changed && !haveAugmentedParent) {
+                        changed = parent.augment();
+                    }
+                    N grandparent = parent.parent;
+                    if (grandparent == null) {
+                        break;
+                    } else if (grandparent.left == parent) {
+                        sibling = grandparent.right;
+                    } else {
+                        sibling = grandparent.left;
+                    }
+                    haveAugmentedParent = haveAugmentedGrandparent;
+                    haveAugmentedGrandparent = false;
+                }
+            } else {
+                if (sibling == parent.left) {
+                    if (!sibling.left.isRed) {
+                        sibling.rotateLeft();
+                        sibling = sibling.parent;
+                    }
+                } else if (!sibling.right.isRed) {
+                    sibling.rotateRight();
+                    sibling = sibling.parent;
+                }
+                sibling.isRed = parent.isRed;
+                parent.isRed = false;
+                if (sibling == parent.left) {
+                    sibling.left.isRed = false;
+                    changed = parent.rotateRight();
+                } else {
+                    sibling.right.isRed = false;
+                    changed = parent.rotateLeft();
+                }
+                haveAugmentedParent = haveAugmentedGrandparent;
+                haveAugmentedGrandparent = false;
+                break;
+            }
+        }
+
+        // Update augmentation info
+        N parent = sibling.parent;
+        if (changed && parent != null) {
+            if (!haveAugmentedParent) {
+                changed = parent.augment();
+            }
+            if (changed && parent.parent != null) {
+                parent = parent.parent;
+                if (!haveAugmentedGrandparent) {
+                    changed = parent.augment();
+                }
+                if (changed) {
+                    for (parent = parent.parent; parent != null; parent = parent.parent) {
+                        if (!parent.augment()) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Removes this node from the tree that contains it.  The effect of this method on the fields of this node is
+     * unspecified.  This method assumes that this is not a leaf node.  This method is more efficient than remove() if
+     * augment() might return false.
+     *
+     * If the node has two children, we begin by moving the node's successor to its former position, by changing the
+     * successor's "left", "right", "parent", and isRed fields.
+     */
+    public void removeWithoutGettingRoot() {
+        if (isLeaf()) {
+            throw new IllegalArgumentException("Attempted to remove a leaf node");
+        }
+        N replacement;
+        if (left.isLeaf() || right.isLeaf()) {
+            replacement = null;
+        } else {
+            replacement = swapWithSuccessor();
+        }
+
+        N child;
+        if (!left.isLeaf()) {
+            child = left;
+        } else if (!right.isLeaf()) {
+            child = right;
+        } else {
+            child = null;
+        }
+
+        if (child != null) {
+            // Replace this node with its child
+            child.parent = parent;
+            if (parent != null) {
+                if (parent.left == this) {
+                    parent.left = child;
+                } else {
+                    parent.right = child;
+                }
+            }
+            child.isRed = false;
+
+            if (child.parent != null) {
+                N parent;
+                for (parent = child.parent; parent != null; parent = parent.parent) {
+                    if (!parent.augment()) {
+                        break;
+                    }
+                }
+            }
+        } else if (parent != null) {
+            // Replace this node with a leaf node
+            N leaf = left;
+            N parent = this.parent;
+            N sibling;
+            if (parent.left == this) {
+                parent.left = leaf;
+                sibling = parent.right;
+            } else {
+                parent.right = leaf;
+                sibling = parent.left;
+            }
+
+            if (!isRed) {
+                RedBlackNode<N> siblingNode = sibling;
+                siblingNode.fixSiblingDeletion();
+            } else {
+                while (parent != null) {
+                    if (!parent.augment()) {
+                        break;
+                    }
+                    parent = parent.parent;
+                }
+            }
+        }
+
+        if (replacement != null) {
+            replacement.augment();
+            for (N parent = replacement.parent; parent != null; parent = parent.parent) {
+                if (!parent.augment()) {
+                    break;
+                }
+            }
+        }
+
+        // Clear any previously existing links, so that we're more likely to encounter an exception if we attempt to
+        // access the removed node
+        parent = null;
+        left = null;
+        right = null;
+        isRed = true;
+    }
+
+    /**
+     * Removes this node from the tree that contains it.  The effect of this method on the fields of this node is
+     * unspecified.  This method assumes that this is not a leaf node.
+     *
+     * If the node has two children, we begin by moving the node's successor to its former position, by changing the
+     * successor's "left", "right", "parent", and isRed fields.
+     *
+     * @return The root of the resulting tree.
+     */
+    public N remove() {
+        if (isLeaf()) {
+            throw new IllegalArgumentException("Attempted to remove a leaf node");
+        }
+
+        // Find an arbitrary non-leaf node in the tree other than this node
+        N node;
+        if (parent != null) {
+            node = parent;
+        } else if (!left.isLeaf()) {
+            node = left;
+        } else if (!right.isLeaf()) {
+            node = right;
+        } else {
+            return left;
+        }
+
+        removeWithoutGettingRoot();
+        return node.root();
+    }
+
+    /**
+     * Returns the root of a perfectly height-balanced subtree containing the next "size" (non-leaf) nodes from
+     * "iterator", in iteration order.  This method is responsible for setting the "left", "right", "parent", and isRed
+     * fields of the nodes, and calling augment() as appropriate.  It ignores the initial values of the "left", "right",
+     * "parent", and isRed fields.
+     * @param iterator The nodes.
+     * @param size The number of nodes.
+     * @param height The "height" of the subtree's root node above the deepest leaf in the tree that contains it.  Since
+     *     insertion fixup is slow if there are too many red nodes and deleteion fixup is slow if there are too few red
+     *     nodes, we compromise and have red nodes at every fourth level.  We color a node red iff its "height" is equal
+     *     to 1 mod 4.
+     * @param leaf The leaf node.
+     * @return The root of the subtree.
+     */
+    private static <N extends RedBlackNode<N>> N createTree(
+            Iterator<? extends N> iterator, int size, int height, N leaf) {
+        if (size == 0) {
+            return leaf;
+        } else {
+            N left = createTree(iterator, (size - 1) / 2, height - 1, leaf);
+            N node = iterator.next();
+            N right = createTree(iterator, size / 2, height - 1, leaf);
+
+            node.isRed = height % 4 == 1;
+            node.left = left;
+            node.right = right;
+            if (!left.isLeaf()) {
+                left.parent = node;
+            }
+            if (!right.isLeaf()) {
+                right.parent = node;
+            }
+
+            node.augment();
+            return node;
+        }
+    }
+
+    /**
+     * Returns the root of a perfectly height-balanced tree containing the specified nodes, in iteration order. This
+     * method is responsible for setting the "left", "right", "parent", and isRed fields of the nodes (excluding
+     * "leaf"), and calling augment() as appropriate. It ignores the initial values of the "left", "right", "parent",
+     * and isRed fields.
+     * @param nodes The nodes.
+     * @param leaf The leaf node.
+     * @return The root of the tree.
+     */
+    public static <N extends RedBlackNode<N>> N createTree(Collection<? extends N> nodes, N leaf) {
+        int size = nodes.size();
+        if (size == 0) {
+            return leaf;
+        }
+
+        int height = 0;
+        for (int subtreeSize = size; subtreeSize > 0; subtreeSize /= 2) {
+            height++;
+        }
+
+        N node = createTree(nodes.iterator(), size, height, leaf);
+        node.parent = null;
+        node.isRed = false;
+        return node;
+    }
+
+    /**
+     * Concatenates to the end of the tree rooted at this node.  To be precise, given that all of the nodes in this
+     * precede the node "pivot", which precedes all of the nodes in "last", this returns the root of a tree containing
+     * all of these nodes.  This method destroys the trees rooted at "this" and "last".  We treat "pivot" as a solitary
+     * node that does not belong to any tree, and we ignore its initial "parent", "left", "right", and isRed fields.
+     * This method assumes that this node and "last" are the roots of their respective trees.
+     *
+     * This method takes O(log N) time.  It is more efficient than inserting "pivot" and then calling concatenate(last).
+     * It is considerably more efficient than inserting "pivot" and all of the nodes in "last".
+     */
+    public N concatenate(N last, N pivot) {
+        // If the black height of "first", where first = this, is less than or equal to that of "last", starting at the
+        // root of "last", we keep going left until we reach a black node whose black height is equal to that of
+        // "first".  Then, we make "pivot" the parent of that node and of "first", coloring it red, and perform
+        // insertion fixup on the pivot.  If the black height of "first" is greater than that of "last", we do the
+        // mirror image of the above.
+
+        if (parent != null) {
+            throw new IllegalArgumentException("This is not the root of a tree");
+        }
+        if (last.parent != null) {
+            throw new IllegalArgumentException("\"last\" is not the root of a tree");
+        }
+
+        // Compute the black height of the trees
+        int firstBlackHeight = 0;
+        @SuppressWarnings("unchecked")
+        N first = (N)this;
+        for (N node = first; node != null; node = node.right) {
+            if (!node.isRed) {
+                firstBlackHeight++;
+            }
+        }
+        int lastBlackHeight = 0;
+        for (N node = last; node != null; node = node.right) {
+            if (!node.isRed) {
+                lastBlackHeight++;
+            }
+        }
+
+        // Identify the children and parent of pivot
+        N firstChild = first;
+        N lastChild = last;
+        N parent;
+        if (firstBlackHeight <= lastBlackHeight) {
+            parent = null;
+            int blackHeight = lastBlackHeight;
+            while (blackHeight > firstBlackHeight) {
+                if (!lastChild.isRed) {
+                    blackHeight--;
+                }
+                parent = lastChild;
+                lastChild = lastChild.left;
+            }
+            if (lastChild.isRed) {
+                parent = lastChild;
+                lastChild = lastChild.left;
+            }
+        } else {
+            parent = null;
+            int blackHeight = firstBlackHeight;
+            while (blackHeight > lastBlackHeight) {
+                if (!firstChild.isRed) {
+                    blackHeight--;
+                }
+                parent = firstChild;
+                firstChild = firstChild.right;
+            }
+            if (firstChild.isRed) {
+                parent = firstChild;
+                firstChild = firstChild.right;
+            }
+        }
+
+        // Add "pivot" to the tree
+        pivot.isRed = true;
+        pivot.parent = parent;
+        if (parent != null) {
+            if (firstBlackHeight < lastBlackHeight) {
+                parent.left = pivot;
+            } else {
+                parent.right = pivot;
+            }
+        }
+        pivot.left = firstChild;
+        if (!firstChild.isLeaf()) {
+            firstChild.parent = pivot;
+        }
+        pivot.right = lastChild;
+        if (!lastChild.isLeaf()) {
+            lastChild.parent = pivot;
+        }
+
+        // Perform insertion fixup
+        return pivot.fixInsertion();
+    }
+
+    /**
+     * Concatenates the tree rooted at "last" to the end of the tree rooted at this node.  To be precise, given that all
+     * of the nodes in this precede all of the nodes in "last", this returns the root of a tree containing all of these
+     * nodes.  This method destroys the trees rooted at "this" and "last".  It assumes that this node and "last" are the
+     * roots of their respective trees.  This method takes O(log N) time.  It is considerably more efficient than
+     * inserting all of the nodes in "last".
+     */
+    public N concatenate(N last) {
+        if (parent != null || last.parent != null) {
+            throw new IllegalArgumentException("The node is not the root of a tree");
+        }
+        if (isLeaf()) {
+            return last;
+        } else if (last.isLeaf()) {
+            @SuppressWarnings("unchecked")
+            N nThis = (N)this;
+            return nThis;
+        } else {
+            N node = last.min();
+            last = node.remove();
+            return concatenate(last, node);
+        }
+    }
+
+    /**
+     * Splits the tree rooted at this node into two trees, so that the first element of the return value is the root of
+     * a tree consisting of the nodes that were before the specified node, and the second element of the return value is
+     * the root of a tree consisting of the nodes that were equal to or after the specified node. This method is
+     * destructive, meaning it does not preserve the original tree. It assumes that this node is the root and is in the
+     * same tree as splitNode. It takes O(log N) time. It is considerably more efficient than removing all of the
+     * nodes at or after splitNode and then creating a new tree from those nodes.
+     * @param The node at which to split the tree.
+     * @return An array consisting of the resulting trees.
+     */
+    public N[] split(N splitNode) {
+        // To split the tree, we accumulate a pre-split tree and a post-split tree.  We walk down the tree toward the
+        // position where we are splitting.  Whenever we go left, we concatenate the right subtree with the post-split
+        // tree, and whenever we go right, we concatenate the pre-split tree with the left subtree.  We use the
+        // concatenation algorithm described in concatenate(Object, Object).  For the pivot, we use the last node where
+        // we went left in the case of a left move, and the last node where we went right in the case of a right move.
+        //
+        // The method uses the following variables:
+        //
+        // node: The current node in our walk down the tree.
+        // first: A node on the right spine of the pre-split tree.  At the beginning of each iteration, it is the black
+        //     node with the same black height as "node".  If the pre-split tree is empty, this is null instead.
+        // firstParent: The parent of "first".  If the pre-split tree is empty, this is null.  Otherwise, this is the
+        //     same as first.parent, unless first.isLeaf().
+        // firstPivot: The node where we last went right, i.e. the next node to use as a pivot when concatenating with
+        //     the pre-split tree.
+        // advanceFirst: Whether to set "first" to be its next black descendant at the end of the loop.
+        // last, lastParent, lastPivot, advanceLast: Analogous to "first", firstParent, firstPivot, and advanceFirst,
+        //     but for the post-split tree.
+        if (parent != null) {
+            throw new IllegalArgumentException("This is not the root of a tree");
+        }
+        if (isLeaf() || splitNode.isLeaf()) {
+            throw new IllegalArgumentException("The root or the split node is a leaf");
+        }
+
+        // Create an array containing the path from the root to splitNode
+        int depth = 1;
+        N parent;
+        for (parent = splitNode; parent.parent != null; parent = parent.parent) {
+            depth++;
+        }
+        if (parent != this) {
+            throw new IllegalArgumentException("The split node does not belong to this tree");
+        }
+        RedBlackNode<?>[] path = new RedBlackNode<?>[depth];
+        for (parent = splitNode; parent != null; parent = parent.parent) {
+            depth--;
+            path[depth] = parent;
+        }
+
+        @SuppressWarnings("unchecked")
+        N node = (N)this;
+        N first = null;
+        N firstParent = null;
+        N last = null;
+        N lastParent = null;
+        N firstPivot = null;
+        N lastPivot = null;
+        while (!node.isLeaf()) {
+            boolean advanceFirst = !node.isRed && firstPivot != null;
+            boolean advanceLast = !node.isRed && lastPivot != null;
+            if ((depth + 1 < path.length && path[depth + 1] == node.left) || depth + 1 == path.length) {
+                // Left move
+                if (lastPivot == null) {
+                    // The post-split tree is empty
+                    last = node.right;
+                    last.parent = null;
+                    if (last.isRed) {
+                        last.isRed = false;
+                        lastParent = last;
+                        last = last.left;
+                    }
+                } else {
+                    // Concatenate node.right and the post-split tree
+                    if (node.right.isRed) {
+                        node.right.isRed = false;
+                    } else if (!node.isRed) {
+                        lastParent = last;
+                        last = last.left;
+                        if (last.isRed) {
+                            lastParent = last;
+                            last = last.left;
+                        }
+                        advanceLast = false;
+                    }
+                    lastPivot.isRed = true;
+                    lastPivot.parent = lastParent;
+                    if (lastParent != null) {
+                        lastParent.left = lastPivot;
+                    }
+                    lastPivot.left = node.right;
+                    if (!lastPivot.left.isLeaf()) {
+                        lastPivot.left.parent = lastPivot;
+                    }
+                    lastPivot.right = last;
+                    if (!last.isLeaf()) {
+                        last.parent = lastPivot;
+                    }
+                    last = lastPivot.left;
+                    lastParent = lastPivot;
+                    lastPivot.fixInsertionWithoutGettingRoot(false);
+                }
+                lastPivot = node;
+                node = node.left;
+            } else {
+                // Right move
+                if (firstPivot == null) {
+                    // The pre-split tree is empty
+                    first = node.left;
+                    first.parent = null;
+                    if (first.isRed) {
+                        first.isRed = false;
+                        firstParent = first;
+                        first = first.right;
+                    }
+                } else {
+                    // Concatenate the post-split tree and node.left
+                    if (node.left.isRed) {
+                        node.left.isRed = false;
+                    } else if (!node.isRed) {
+                        firstParent = first;
+                        first = first.right;
+                        if (first.isRed) {
+                            firstParent = first;
+                            first = first.right;
+                        }
+                        advanceFirst = false;
+                    }
+                    firstPivot.isRed = true;
+                    firstPivot.parent = firstParent;
+                    if (firstParent != null) {
+                        firstParent.right = firstPivot;
+                    }
+                    firstPivot.right = node.left;
+                    if (!firstPivot.right.isLeaf()) {
+                        firstPivot.right.parent = firstPivot;
+                    }
+                    firstPivot.left = first;
+                    if (!first.isLeaf()) {
+                        first.parent = firstPivot;
+                    }
+                    first = firstPivot.right;
+                    firstParent = firstPivot;
+                    firstPivot.fixInsertionWithoutGettingRoot(false);
+                }
+                firstPivot = node;
+                node = node.right;
+            }
+
+            depth++;
+
+            // Update "first" and "last" to be the nodes at the proper black height
+            if (advanceFirst) {
+                firstParent = first;
+                first = first.right;
+                if (first.isRed) {
+                    firstParent = first;
+                    first = first.right;
+                }
+            }
+            if (advanceLast) {
+                lastParent = last;
+                last = last.left;
+                if (last.isRed) {
+                    lastParent = last;
+                    last = last.left;
+                }
+            }
+        }
+
+        // Add firstPivot to the pre-split tree
+        N leaf = node;
+        if (first == null) {
+            first = leaf;
+        } else {
+            firstPivot.isRed = true;
+            firstPivot.parent = firstParent;
+            if (firstParent != null) {
+                firstParent.right = firstPivot;
+            }
+            firstPivot.left = leaf;
+            firstPivot.right = leaf;
+            firstPivot.fixInsertionWithoutGettingRoot(false);
+            for (first = firstPivot; first.parent != null; first = first.parent) {
+                first.augment();
+            }
+            first.augment();
+        }
+
+        // Add lastPivot to the post-split tree
+        lastPivot.isRed = true;
+        lastPivot.parent = lastParent;
+        if (lastParent != null) {
+            lastParent.left = lastPivot;
+        }
+        lastPivot.left = leaf;
+        lastPivot.right = leaf;
+        lastPivot.fixInsertionWithoutGettingRoot(false);
+        for (last = lastPivot; last.parent != null; last = last.parent) {
+            last.augment();
+        }
+        last.augment();
+
+        @SuppressWarnings("unchecked")
+        N[] result = (N[])Array.newInstance(getClass(), 2);
+        result[0] = first;
+        result[1] = last;
+        return result;
+    }
+
+    /**
+     * Returns the lowest common ancestor of this node and "other" - the node that is an ancestor of both and is not the
+     * parent of a node that is an ancestor of both. Assumes that this is in the same tree as "other". Assumes that
+     * neither "this" nor "other" is a leaf node. This method may return "this" or "other".
+     *
+     * Note that while it is possible to compute the lowest common ancestor in O(P) time, where P is the length of the
+     * path from this node to "other", the "lca" method is not guaranteed to take O(P) time. If your application
+     * requires this, then you should write your own lowest common ancestor method.
+     */
+    public N lca(N other) {
+        if (isLeaf() || other.isLeaf()) {
+            throw new IllegalArgumentException("One of the nodes is a leaf node");
+        }
+
+        // Compute the depth of each node
+        int depth = 0;
+        for (N parent = this.parent; parent != null; parent = parent.parent) {
+            depth++;
+        }
+        int otherDepth = 0;
+        for (N parent = other.parent; parent != null; parent = parent.parent) {
+            otherDepth++;
+        }
+
+        // Go up to nodes of the same depth
+        @SuppressWarnings("unchecked")
+        N parent = (N)this;
+        N otherParent = other;
+        if (depth <= otherDepth) {
+            for (int i = otherDepth; i > depth; i--) {
+                otherParent = otherParent.parent;
+            }
+        } else {
+            for (int i = depth; i > otherDepth; i--) {
+                parent = parent.parent;
+            }
+        }
+
+        // Find the LCA
+        while (parent != otherParent) {
+            parent = parent.parent;
+            otherParent = otherParent.parent;
+        }
+        if (parent != null) {
+            return parent;
+        } else {
+            throw new IllegalArgumentException("The nodes do not belong to the same tree");
+        }
+    }
+
+    /**
+     * Returns an integer comparing the position of this node in the tree that contains it with that of "other". Returns
+     * a negative number if this is earlier, a positive number if this is later, and 0 if this is at the same position.
+     * Assumes that this is in the same tree as "other". Assumes that neither "this" nor "other" is a leaf node.
+     *
+     * The base class's implementation takes O(log N) time. If a RedBlackNode subclass stores a value used to order the
+     * nodes, then it could override compareTo to compare the nodes' values, which would take O(1) time.
+     *
+     * Note that while it is possible to compare the positions of two nodes in O(P) time, where P is the length of the
+     * path from this node to "other", the default implementation of compareTo is not guaranteed to take O(P) time. If
+     * your application requires this, then you should write your own comparison method.
+     */
+    @Override
+    public int compareTo(N other) {
+        if (isLeaf() || other.isLeaf()) {
+            throw new IllegalArgumentException("One of the nodes is a leaf node");
+        }
+
+        // The algorithm operates as follows: compare the depth of this node to that of "other".  If the depth of
+        // "other" is greater, keep moving up from "other" until we find the ancestor at the same depth.  Then, keep
+        // moving up from "this" and from that node until we reach the lowest common ancestor.  The node that arrived
+        // from the left child of the common ancestor is earlier.  The algorithm is analogous if the depth of "other" is
+        // not greater.
+        if (this == other) {
+            return 0;
+        }
+
+        // Compute the depth of each node
+        int depth = 0;
+        RedBlackNode<N> parent;
+        for (parent = this; parent.parent != null; parent = parent.parent) {
+            depth++;
+        }
+        int otherDepth = 0;
+        N otherParent;
+        for (otherParent = other; otherParent.parent != null; otherParent = otherParent.parent) {
+            otherDepth++;
+        }
+
+        // Go up to nodes of the same depth
+        if (depth < otherDepth) {
+            otherParent = other;
+            for (int i = otherDepth - 1; i > depth; i--) {
+                otherParent = otherParent.parent;
+            }
+            if (otherParent.parent != this) {
+                otherParent = otherParent.parent;
+            } else if (left == otherParent) {
+                return 1;
+            } else {
+                return -1;
+            }
+            parent = this;
+        } else if (depth > otherDepth) {
+            parent = this;
+            for (int i = depth - 1; i > otherDepth; i--) {
+                parent = parent.parent;
+            }
+            if (parent.parent != other) {
+                parent = parent.parent;
+            } else if (other.left == parent) {
+                return -1;
+            } else {
+                return 1;
+            }
+            otherParent = other;
+        } else {
+            parent = this;
+            otherParent = other;
+        }
+
+        // Keep going up until we reach the lowest common ancestor
+        while (parent.parent != otherParent.parent) {
+            parent = parent.parent;
+            otherParent = otherParent.parent;
+        }
+        if (parent.parent == null) {
+            throw new IllegalArgumentException("The nodes do not belong to the same tree");
+        }
+        if (parent.parent.left == parent) {
+            return -1;
+        } else {
+            return 1;
+        }
+    }
+
+    /** Throws a RuntimeException if the RedBlackNode fields of this are not correct for a leaf node. */
+    private void assertIsValidLeaf() {
+        if (left != null || right != null || parent != null || isRed) {
+            throw new RuntimeException("A leaf node's \"left\", \"right\", \"parent\", or isRed field is incorrect");
+        }
+    }
+
+    /**
+     * Throws a RuntimeException if the subtree rooted at this node does not satisfy the red-black properties, excluding
+     * the requirement that the root be black, or it contains a repeated node other than a leaf node.
+     * @param blackHeight The required number of black nodes in each path from this to a leaf node, including this and
+     *     the leaf node.
+     * @param visited The nodes we have reached thus far, other than leaf nodes. This method adds the non-leaf nodes in
+     *     the subtree rooted at this node to "visited".
+     */
+    private void assertSubtreeIsValidRedBlack(int blackHeight, Set<Reference<N>> visited) {
+        @SuppressWarnings("unchecked")
+        N nThis = (N)this;
+        if (left == null || right == null) {
+            assertIsValidLeaf();
+            if (blackHeight != 1) {
+                throw new RuntimeException("Not all root-to-leaf paths have the same number of black nodes");
+            }
+            return;
+        } else if (!visited.add(new Reference<N>(nThis))) {
+            throw new RuntimeException("The tree contains a repeated non-leaf node");
+        } else {
+            int childBlackHeight;
+            if (isRed) {
+                if ((!left.isLeaf() && left.isRed) || (!right.isLeaf() && right.isRed)) {
+                    throw new RuntimeException("A red node has a red child");
+                }
+                childBlackHeight = blackHeight;
+            } else if (blackHeight == 0) {
+                throw new RuntimeException("Not all root-to-leaf paths have the same number of black nodes");
+            } else {
+                childBlackHeight = blackHeight - 1;
+            }
+
+            if (!left.isLeaf() && left.parent != this) {
+                throw new RuntimeException("left.parent != this");
+            }
+            if (!right.isLeaf() && right.parent != this) {
+                throw new RuntimeException("right.parent != this");
+            }
+            RedBlackNode<N> leftNode = left;
+            RedBlackNode<N> rightNode = right;
+            leftNode.assertSubtreeIsValidRedBlack(childBlackHeight, visited);
+            rightNode.assertSubtreeIsValidRedBlack(childBlackHeight, visited);
+        }
+    }
+
+    /** Calls assertNodeIsValid() on every node in the subtree rooted at this node. */
+    private void assertNodesAreValid() {
+        assertNodeIsValid();
+        if (left != null) {
+            RedBlackNode<N> leftNode = left;
+            RedBlackNode<N> rightNode = right;
+            leftNode.assertNodesAreValid();
+            rightNode.assertNodesAreValid();
+        }
+    }
+
+    /**
+     * Throws a RuntimeException if the subtree rooted at this node is not a valid red-black tree, e.g. if a red node
+     * has a red child or it contains a non-leaf node "node" for which node.left.parent != node. (If parent != null,
+     * it's okay if isRed is true.) This method is useful for debugging. See also assertSubtreeIsValid().
+     */
+    public void assertSubtreeIsValidRedBlack() {
+        if (isLeaf()) {
+            assertIsValidLeaf();
+        } else {
+            if (parent == null && isRed) {
+                throw new RuntimeException("The root is red");
+            }
+
+            // Compute the black height of the tree
+            Set<Reference<N>> nodes = new HashSet<Reference<N>>();
+            int blackHeight = 0;
+            @SuppressWarnings("unchecked")
+            N node = (N)this;
+            while (node != null) {
+                if (!nodes.add(new Reference<N>(node))) {
+                    throw new RuntimeException("The tree contains a repeated non-leaf node");
+                }
+                if (!node.isRed) {
+                    blackHeight++;
+                }
+                node = node.left;
+            }
+
+            assertSubtreeIsValidRedBlack(blackHeight, new HashSet<Reference<N>>());
+        }
+    }
+
+    /**
+     * Throws a RuntimeException if we detect a problem with the subtree rooted at this node, such as a red child of a
+     * red node or a non-leaf descendant "node" for which node.left.parent != node.  This method is useful for
+     * debugging.  RedBlackNode subclasses may want to override assertSubtreeIsValid() to call assertOrderIsValid.
+     */
+    public void assertSubtreeIsValid() {
+        assertSubtreeIsValidRedBlack();
+        assertNodesAreValid();
+    }
+
+    /**
+     * Throws a RuntimeException if the nodes in the subtree rooted at this node are not in the specified order or they
+     * do not lie in the specified range.  Assumes that the subtree rooted at this node is a valid binary tree, i.e. it
+     * has no repeated nodes other than leaf nodes.
+     * @param comparator A comparator indicating how the nodes should be ordered.
+     * @param start The lower limit for nodes in the subtree, if any.
+     * @param end The upper limit for nodes in the subtree, if any.
+     */
+    private void assertOrderIsValid(Comparator<? super N> comparator, N start, N end) {
+        if (!isLeaf()) {
+            @SuppressWarnings("unchecked")
+            N nThis = (N)this;
+            if (start != null && comparator.compare(nThis, start) < 0) {
+                throw new RuntimeException("The nodes are not ordered correctly");
+            }
+            if (end != null && comparator.compare(nThis, end) > 0) {
+                throw new RuntimeException("The nodes are not ordered correctly");
+            }
+            RedBlackNode<N> leftNode = left;
+            RedBlackNode<N> rightNode = right;
+            leftNode.assertOrderIsValid(comparator, start, nThis);
+            rightNode.assertOrderIsValid(comparator, nThis, end);
+        }
+    }
+
+    /**
+     * Throws a RuntimeException if the nodes in the subtree rooted at this node are not in the specified order.
+     * Assumes that this is a valid binary tree, i.e. there are no repeated nodes other than leaf nodes.  This method is
+     * useful for debugging.  RedBlackNode subclasses may want to override assertSubtreeIsValid() to call
+     * assertOrderIsValid.
+     * @param comparator A comparator indicating how the nodes should be ordered.  If this is null, we use the nodes'
+     *     natural order, as in N.compareTo.
+     */
+    public void assertOrderIsValid(Comparator<? super N> comparator) {
+        if (comparator == null) {
+            comparator = naturalOrder();
+        }
+        assertOrderIsValid(comparator, null, null);
+    }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Reference.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Reference.java
new file mode 100644
index 00000000..a25c167d
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/Reference.java
@@ -0,0 +1,51 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 btrekkie
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval;
+
+/**
+ * Wraps a value using reference equality.  In other words, two references are equal only if their values are the same
+ * object instance, as in ==.
+ * @param <T> The type of value.
+ */
+class Reference<T> {
+    /** The value this wraps. */
+    private final T value;
+
+    public Reference(T value) {
+        this.value = value;
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Reference)) {
+            return false;
+        }
+        Reference<?> reference = (Reference<?>)obj;
+        return value == reference.value;
+    }
+
+    @Override
+    public int hashCode() {
+        return System.identityHashCode(value);
+    }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/IntervalAggregatorFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/IntervalAggregatorFactory.xtend
new file mode 100644
index 00000000..dee31f67
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/IntervalAggregatorFactory.xtend
@@ -0,0 +1,50 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.aggregators
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalAggregationMode
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalAggregationOperator
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.AggregatorType
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.BoundAggregator
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IAggregatorFactory
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+@AggregatorType(parameterTypes=#[Interval], returnTypes=#[Interval])
+abstract class IntervalAggregatorFactory implements IAggregatorFactory {
+        val IntervalAggregationMode mode
+
+        @FinalFieldsConstructor
+        protected new() {
+        }
+
+        override getAggregatorLogic(Class<?> domainClass) {
+                if (domainClass == Interval) {
+                        new BoundAggregator(new IntervalAggregationOperator(mode), Interval, Interval)
+                } else {
+                        throw new IllegalArgumentException("Unknown domain class: " + domainClass)
+                }
+        }
+}
+
+class intervalSum extends IntervalAggregatorFactory {
+        new() {
+                super(IntervalAggregationMode.SUM)
+        }
+}
+
+class intervalMin extends IntervalAggregatorFactory {
+        new() {
+                super(IntervalAggregationMode.MIN)
+        }
+}
+
+class intervalMax extends IntervalAggregatorFactory {
+        new() {
+                super(IntervalAggregationMode.MAX)
+        }
+}
+
+class intervalJoin extends IntervalAggregatorFactory {
+        new() {
+                super(IntervalAggregationMode.JOIN)
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/intervalHull.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/intervalHull.xtend
new file mode 100644
index 00000000..72605f57
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/interval/aggregators/intervalHull.xtend
@@ -0,0 +1,74 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.aggregators
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.Interval
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.IntervalHullAggregatorOperator
+import java.math.BigDecimal
+import java.math.BigInteger
+import java.math.MathContext
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.AggregatorType
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.BoundAggregator
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IAggregatorFactory
+
+@AggregatorType(parameterTypes=#[BigDecimal, BigInteger, Byte, Double, Float, Integer, Long, Short], returnTypes=#[
+        Interval, Interval, Interval, Interval, Interval, Interval, Interval, Interval])
+class intervalHull implements IAggregatorFactory {
+
+        override getAggregatorLogic(Class<?> domainClass) {
+                new BoundAggregator(getAggregationOperator(domainClass), domainClass, Interval)
+        }
+
+        private def getAggregationOperator(Class<?> domainClass) {
+                switch (domainClass) {
+                        case BigDecimal:
+                                new IntervalHullAggregatorOperator<BigDecimal>() {
+                                        override protected toBigDecimal(BigDecimal value, MathContext mc) {
+                                                value.round(mc)
+                                        }
+                                }
+                        case BigInteger:
+                                new IntervalHullAggregatorOperator<BigInteger>() {
+                                        override protected toBigDecimal(BigInteger value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        case Byte:
+                                new IntervalHullAggregatorOperator<Byte>() {
+                                        override protected toBigDecimal(Byte value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        case Double:
+                                new IntervalHullAggregatorOperator<Double>() {
+                                        override protected toBigDecimal(Double value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        case Float:
+                                new IntervalHullAggregatorOperator<Float>() {
+                                        override protected toBigDecimal(Float value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        case Integer:
+                                new IntervalHullAggregatorOperator<Integer>() {
+                                        override protected toBigDecimal(Integer value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        case Long:
+                                new IntervalHullAggregatorOperator<Long>() {
+                                        override protected toBigDecimal(Long value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        case Short:
+                                new IntervalHullAggregatorOperator<Short>() {
+                                        override protected toBigDecimal(Short value, MathContext mc) {
+                                                new BigDecimal(value, mc)
+                                        }
+                                }
+                        default:
+                                throw new IllegalArgumentException("Unknown domain class: " + domainClass)
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend
index d6a15c1a..0e0f1f02 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend
@@ -1,209 +1,150 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

 

-import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem

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

-import org.eclipse.emf.ecore.EClass

+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem

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

-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

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

 

 class GenericTypeIndexer extends TypeIndexer {

-        val PatternGenerator base;

-        

         new(PatternGenerator base) {

-                this.base = base

+                super(base)

         }

+

         override requiresTypeAnalysis() { false }

-        

-        public override getRequiredQueries() '''

-        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/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..1b0db90e 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,6 +16,7 @@ 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.RelationConstraints

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

 import java.util.HashMap

 import java.util.Map

@@ -26,22 +26,26 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
 import org.eclipse.xtend.lib.annotations.Accessors

 

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

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagatorStrategy

 

 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 TypeRefinementGenerator typeRefinementGenerator //= new RefinementGenerator(this)

-        @Accessors(PUBLIC_GETTER) val RelationRefinementGenerator relationRefinementGenerator = new RelationRefinementGenerator(this)

-        

-        public new(TypeInferenceMethod typeInferenceMethod) {

-                if(typeInferenceMethod == TypeInferenceMethod.Generic) {

+        @Accessors(PUBLIC_GETTER) val UnfinishedIndexer unfinishedIndexer

+        @Accessors(PUBLIC_GETTER) val TypeRefinementGenerator typeRefinementGenerator // = new RefinementGenerator(this)

+        @Accessors(PUBLIC_GETTER) val RelationRefinementGenerator relationRefinementGenerator = new RelationRefinementGenerator(

+                this)

+

+        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,112 +53,100 @@ 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 (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

         ) {

-                

+

                 return '''

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

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

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

@@ -221,7 +213,7 @@ class PatternGenerator {
                         //////////

                         // 1.1.1 primitive Type Indexers

                         //////////

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

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

 «««                          find interpretation(problem,interpretation);

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

 «««                  }

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

@@ -302,6 +294,6 @@ class PatternGenerator {
                         // 4.3 Relation refinement

                         //////////

                         «relationRefinementGenerator.generateRefineReference(problem)»

-                        '''

+                '''

         }

 }

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..eadf0ae0 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
@@ -2,16 +2,23 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
 

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

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

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

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

 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem

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

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

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

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

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

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.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.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

@@ -19,79 +26,115 @@ 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

+@Data

+class GeneratedPatterns {

+        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<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<RelationDefinition, ModalPatternQueries> modalRelationQueries

         public Collection<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allQueries

 }

 

+@Data

+class ModalPatternQueries {

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

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

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

+}

+

+@Data

+class UnifinishedMultiplicityQueries {

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

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

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

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

+}

+

 class PatternProvider {

-        

+

         val TypeAnalysis typeAnalysis = new TypeAnalysis

-        

-        public def generateQueries(

-                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, 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 baseIndexerFile = patternGenerator.transformBaseProperties(problem, emptySolution, fqn2Query,

+                        typeAnalysisResult, relationConstraints)

+                if (writeToFile) {

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

                 }

                 val ParseUtil parseUtil = new ParseUtil

                 val generatedQueries = parseUtil.parse(baseIndexerFile)

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

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

+                        relationConstraints, generatedQueries)

                 return runtimeQueries

         }

-        

+

         private def GeneratedPatterns calclulateRuntimeQueries(

                 PatternGenerator patternGenerator,

                 LogicProblem problem,

                 PartialInterpretation emptySolution,

                 TypeAnalysisResult typeAnalysisResult,

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

+                RelationConstraints relationConstraints,

+                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 invalidWFQueries = patternGenerator.invalidIndexer.getInvalidateByWfQueryNames(problem).mapValues [

+                        it.lookup(queries)

+                ]

+                val unfinishedWFQueries = patternGenerator.unfinishedIndexer.getUnfinishedWFQueryNames(problem).mapValues [

+                        it.lookup(queries)

+                ]

+                val multiplicityConstraintQueries = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(

+                        relationConstraints.multiplicityConstraints).mapValues [

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

+                                unrepairableMultiplicityQueryName?.lookup(queries),

+                                remainingInverseMultiplicityQueryName?.lookup(queries), remainingContentsQueryName?.lookup(queries))

+                ]

+                val hasElementInContainmentQuery = patternGenerator.typeRefinementGenerator.hasElementInContainmentName.lookup(

+                        queries)

+                val unfinishedMultiplicityQueries = multiplicityConstraintQueries.entrySet.filter [

+                        value.unfinishedMultiplicityQuery !== null

+                ].toMap([key.relation], [value.unfinishedMultiplicityQuery])

+                val refineObjectsQueries = patternGenerator.typeRefinementGenerator.

+                        getRefineObjectQueryNames(problem, emptySolution, typeAnalysisResult).mapValues[it.lookup(queries)]

+                val refineTypeQueries = patternGenerator.typeRefinementGenerator.getRefineTypeQueryNames(problem, emptySolution,

+                        typeAnalysisResult).mapValues[it.lookup(queries)]

+                val refineRelationQueries = patternGenerator.relationRefinementGenerator.getRefineRelationQueries(problem).

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

+                        multiplicityConstraintQueries,

+                        hasElementInContainmentQuery,

                         unfinishedMultiplicityQueries,

                         refineObjectsQueries,

                         refineTypeQueries,

                         refineRelationQueries,

+                        modalRelationQueries,

                         queries.values

                 )

         }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
index 9723373f..cedcec5a 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
@@ -71,7 +71,7 @@ class RelationDefinitionIndexer {
                 ]

         }

         

-        private def relationDefinitionName(RelationDefinition relation, Modality modality)

+        def String relationDefinitionName(RelationDefinition relation, Modality modality)

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

         

         private def canonizeName(PVariable v) {

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..fa73c861 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend
@@ -9,77 +9,71 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
 

 class RelationRefinementGenerator {

         PatternGenerator base;

+

         public new(PatternGenerator base) {

                 this.base = base

         }

-        

-        def CharSequence generateRefineReference(LogicProblem p) {

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

-                }

+

+        def CharSequence generateRefineReference(LogicProblem p) '''

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

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

         }

-        

 

         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 +84,4 @@ class RelationRefinementGenerator {
                 }

                 return list

         }

-}
\ No newline at end of file
+}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend
index d1d57189..7d687e99 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,122 @@
 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
+}

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..15b5a047 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,198 @@
 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.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 unfinishedMultiplicityQueryName

+        val String unrepairableMultiplicityQueryName

+        val String remainingInverseMultiplicityQueryName

+        val String remainingContentsQueryName

+}

 

 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.constrainsUnfinished»

+                                private pattern «unfinishedMultiplicityName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, missingMultiplicity:java Integer) {

+                                        find interpretation(problem,interpretation);

+                                        find mustExist(problem,interpretation,object);

+                                        «base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»

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

+                                        check(numberOfExistingReferences < «constraint.lowerBound»);

+                                        missingMultiplicity == eval(«constraint.lowerBound»-numberOfExistingReferences);

+                                }

+                                

+                                pattern «unfinishedMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, missingMultiplicity:java Integer) {

+                                        find interpretation(problem,interpretation);

+                                        missingMultiplicity == sum find «unfinishedMultiplicityName(constraint)»_helper(problem, interpretation, _, #_);

+                                }

+                        «ENDIF»

+                        

+                        «IF indexUpperMultiplicities»

+                                «IF constraint.constrainsUnrepairable || constraint.constrainsRemainingInverse»

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

+                                                find interpretation(problem,interpretation);

+                                                find mustExist(problem,interpretation,source);

+                                                «base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"source")»

+                                                find mustExist(problem,interpretation,target);

+                                                «base.typeIndexer.referInstanceOf(constraint.targetType,Modality::MUST,"target")»

+                                                neg «base.referRelation(constraint.relation,"source","target",Modality.MUST,fqn2PQuery)»

+                                                «base.referRelation(constraint.relation,"source","target",Modality.MAY,fqn2PQuery)»

+                                        }

+                                «ENDIF»

+                                

+                                «IF constraint.constrainsUnrepairable»

+                                        private pattern «unrepairableMultiplicityName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, unrepairableMultiplicity:java Integer) {

+                                                find interpretation(problem,interpretation);

+                                                find mustExist(problem,interpretation,object);

+                                                «base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»

+                                                find «unfinishedMultiplicityName(constraint)»_helper(problem, interpretation, object, missingMultiplicity);

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

+                                                check(numberOfRepairMatches < missingMultiplicity);

+                                                unrepairableMultiplicity == eval(missingMultiplicity-numberOfRepairMatches);

+                                        }

+                                        

+                                        private pattern «unrepairableMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, unrepairableMultiplicity:java Integer) {

+                                                find interpretation(problem,interpretation);

+                                                unrepairableMultiplicity == max find «unrepairableMultiplicityName(constraint)»_helper(problem, interpretation, _, #_);

+                                        } or {

+                                                find interpretation(problem,interpretation);

+                                                neg find «unrepairableMultiplicityName(constraint)»_helper(problem, interpretation, _, _);

+                                                unrepairableMultiplicity == 0;

+                                        }

+                                «ENDIF»

+                                

+                                «IF constraint.constrainsRemainingInverse»

+                                        private pattern «remainingMultiplicityName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, remainingMultiplicity:java Integer) {

+                                                find interpretation(problem,interpretation);

+                                                find mustExist(problem,interpretation,object);

+                                                «base.typeIndexer.referInstanceOf(constraint.targetType,Modality::MUST,"object")»

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

+                                                check(numberOfExistingReferences < «constraint.inverseUpperBound»);

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

+                                                remainingMultiplicity == eval(Math.min(«constraint.inverseUpperBound»-numberOfExistingReferences, numberOfRepairMatches));

+                                        }

+                                        

+                                        pattern «remainingMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, remainingMultiplicity:java Integer) {

+                                                find interpretation(problem,interpretation);

+                                                remainingMultiplicity == sum find «remainingMultiplicityName(constraint)»_helper(problem, interpretation, _, #_);

+                                        }

+                                «ENDIF»

+                                

+                                «IF constraint.constrainsRemainingContents»

+                                        «IF constraint.upperBoundFinite»

+                                                private pattern «remainingContentsName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, remainingMultiplicity:java Integer) {

+                                                        find interpretation(problem,interpretation);

+                                                        find mustExist(problem,interpretation,object);

+                                                        «base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»

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

+                                                        check(numberOfExistingReferences < «constraint.upperBound»);

+                                                        remainingMultiplicity == eval(«constraint.upperBound»-numberOfExistingReferences);

+                                                }

+                                                

+                                                pattern «remainingContentsName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, remainingMultiplicity:java Integer) {

+                                                        find interpretation(problem,interpretation);

+                                                        remainingMultiplicity == sum find «remainingContentsName(constraint)»_helper(problem, interpretation, _, #_);

+                                                }

+                                        «ELSE»

+                                                pattern «remainingContentsName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation) {

+                                                        find interpretation(problem,interpretation);

+                                                        find mustExist(problem,interpretation,object);

+                                                        «base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»

+                                                }

+                                                

+                                                pattern «remainingContentsName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, remainingMultiplicity:java Integer) {

+                                                        find interpretation(problem,interpretation);

+                                                        find «remainingContentsName(constraint)»_helper(problem, interpretation);

+                                                        remainingMultiplicity == -1;

+                                                } or {

+                                                        find interpretation(problem,interpretation);

+                                                        neg find «remainingContentsName(constraint)»_helper(problem, interpretation);

+                                                        remainingMultiplicity == 0;

+                                                }

+                                        «ENDIF»

+                                «ENDIF»

+                        «ENDIF»

                 «ENDFOR»

-                '''

-        }

-        def String unfinishedMultiplicityName(LowerMultiplicityAssertion lowerMultiplicityAssertion) 

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

-                        }

-                }

-        }

-        

-        def getUnfinishedMultiplicityQueries(LogicProblem problem) {

-                val lowerMultiplicities = base.lowerMultiplicities(problem)

-                val map = new LinkedHashMap

-                for(lowerMultiplicity : lowerMultiplicities) {

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

-                }

-                return map

+        '''

+

+        def String unfinishedMultiplicityName(

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

+

+        def String unrepairableMultiplicityName(

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

+

+        private def String repairMatchName(

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

+

+        def String remainingMultiplicityName(

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

+

+        def String remainingContentsName(

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

+

+        def getUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints) {

+                constraints.toInvertedMap [ constraint |

+                        new UnifinishedMultiplicityQueryNames(

+                                if(constraint.constrainsUnfinished) unfinishedMultiplicityName(constraint) else null,

+                                if (indexUpperMultiplicities && constraint.constrainsUnrepairable)

+                                        unrepairableMultiplicityName(constraint)

+                                else

+                                        null,

+                                if (indexUpperMultiplicities && constraint.constrainsRemainingInverse)

+                                        remainingMultiplicityName(constraint)

+                                else

+                                        null,

+                                if (indexUpperMultiplicities && constraint.constrainsRemainingContents)

+                                        remainingContentsName(constraint)

+                                else

+                                        null

+                        )

+                ]

         }

 }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
index e1be2742..b6fdbe06 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,6 +1,6 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules

 

-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.MultiplicityGoalConstraintCalculator

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.MultiplicityGoalConstraintCalculator

 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns

 import java.util.ArrayList

 

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..bf816de9 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
@@ -6,7 +6,7 @@ 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.Type

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

@@ -98,10 +98,12 @@ class RefinementRuleProvider {
                                         val newLink2 = factory2.createBinaryElementRelationLink => [it.param1 = newElement it.param2 = container]

                                         inverseRelationInterpretation.relationlinks+=newLink2

                                         

+                                        val propagatorStartTime = System.nanoTime

+                                        statistics.addExecutionTime(propagatorStartTime-startTime)

+                                        

                                         // Scope propagation

                                         scopePropagator.propagateAdditionToType(typeInterpretation)

-                                        

-                                        statistics.addExecutionTime(System.nanoTime-startTime)

+                                        statistics.addScopePropagationTime(System.nanoTime-propagatorStartTime)

                                 ]

                         } else {

                                 ruleBuilder.action[match |

@@ -132,10 +134,12 @@ class RefinementRuleProvider {
                                         val newLink = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement]

                                         relationInterpretation.relationlinks+=newLink

                                         

+                                        val propagatorStartTime = System.nanoTime

+                                        statistics.addExecutionTime(propagatorStartTime-startTime)

+                                        

                                         // Scope propagation

                                         scopePropagator.propagateAdditionToType(typeInterpretation)

-                                        

-                                        statistics.addExecutionTime(System.nanoTime-startTime)

+                                        statistics.addScopePropagationTime(System.nanoTime-propagatorStartTime)

                                 ]

                         }

                 } else {

@@ -162,29 +166,31 @@ class RefinementRuleProvider {
                                 typeInterpretation.elements += newElement

                                 typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement]

                                 

+                                val propagatorStartTime = System.nanoTime

+                                statistics.addExecutionTime(propagatorStartTime-startTime)

+                                

                                 // Scope propagation

                                 scopePropagator.propagateAdditionToType(typeInterpretation)

-                                

-                                statistics.addExecutionTime(System.nanoTime-startTime)

+                                statistics.addScopePropagationTime(System.nanoTime-propagatorStartTime)

                         ]

                 }

                 return ruleBuilder.build

         }

         

-        def createRelationRefinementRules(GeneratedPatterns patterns, ModelGenerationStatistics statistics) {

+        def createRelationRefinementRules(GeneratedPatterns patterns, ScopePropagator scopePropagator, ModelGenerationStatistics statistics) {

                 val res = new LinkedHashMap

                 for(LHSEntry: patterns.refinerelationQueries.entrySet) {

                         val declaration = LHSEntry.key.key

                         val inverseReference = LHSEntry.key.value

                         val lhs = LHSEntry.value as IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>>

-                        val rule = createRelationRefinementRule(declaration,inverseReference,lhs,statistics)

+                        val rule = createRelationRefinementRule(declaration,inverseReference,lhs,scopePropagator,statistics)

                         res.put(LHSEntry.key,rule)

                 }

                 return res

         }

         

         def private BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>

-                createRelationRefinementRule(RelationDeclaration declaration, Relation inverseRelation, IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, ModelGenerationStatistics statistics)

+                createRelationRefinementRule(RelationDeclaration declaration, Relation inverseRelation, IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, ScopePropagator scopePropagator, ModelGenerationStatistics statistics)

         {

                 val name = '''addRelation_«declaration.name.canonizeName»«IF inverseRelation != null»_and_«inverseRelation.name.canonizeName»«ENDIF»'''

                 val ruleBuilder = factory.createRule

@@ -201,7 +207,13 @@ class RefinementRuleProvider {
                                 val trg = match.get(4) as DefinedElement

                                 val link = createBinaryElementRelationLink => [it.param1 = src it.param2 = trg]

                                 relationInterpretation.relationlinks += link

-                statistics.addExecutionTime(System.nanoTime-startTime)

+                                

+                                val propagatorStartTime = System.nanoTime

+                                statistics.addExecutionTime(propagatorStartTime-startTime)

+                                

+                                // Scope propagation

+                                scopePropagator.propagateAdditionToRelation(declaration)

+                                statistics.addScopePropagationTime(System.nanoTime-propagatorStartTime)

                         ]

                 } else {

                         ruleBuilder.action [ match |

@@ -217,7 +229,13 @@ class RefinementRuleProvider {
                                 relationInterpretation.relationlinks += link

                                 val inverseLink = createBinaryElementRelationLink => [it.param1 = trg it.param2 = src]

                                 inverseInterpretation.relationlinks += inverseLink

-                                statistics.addExecutionTime(System.nanoTime-startTime)

+                                

+                                val propagatorStartTime = System.nanoTime

+                                statistics.addExecutionTime(propagatorStartTime-startTime)

+                                

+                                // Scope propagation

+                                scopePropagator.propagateAdditionToRelation(declaration)

+                                statistics.addScopePropagationTime(System.nanoTime-propagatorStartTime)

                         ]

                 }

 

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

-        

+

+        protected def StringConcatenationClient prettyPrint() {

+                '''(«dataHash»)[«class.simpleName»]'''

+        }

+

+        override toString() {

+                '''

+                        «prettyPrint»

+                '''

+        }

+

 //      @Pure

 //      @Override

 //      override public boolean equals(Object obj) {

@@ -24,34 +35,41 @@ 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

         }

-        

+

+        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 +84,6 @@ import org.eclipse.xtend.lib.annotations.Data
 //                      return false;

 //              return true;

 //      }

-        

 //      @Pure

 //      override public boolean equals(Object obj) {

 //              if (this === obj)

@@ -97,49 +114,70 @@ 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 = 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

+        }

+

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

+                }

+        }

+

         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»]'''

+                '''

+                        «prettyPrint»

+                '''

         }

-        

+

 //      @Pure

 //      @Override

 //      override public boolean equals(Object obj) {

@@ -154,7 +192,6 @@ import org.eclipse.xtend.lib.annotations.Data
 //                      return false;

 //              return true;

 //      }

-        

 //      @Pure

 //      override public boolean equals(Object obj) {

 //              if (this === obj)

@@ -191,24 +228,23 @@ import org.eclipse.xtend.lib.annotations.Data
 //              return true;

 //      }

 }

-

 /*

-@Data

-class ModelDescriptor {

-        int dataHash

-        int unknownElements

-        Map<? extends AbstractNodeDescriptor,Integer> knownElements

-        

-        public new(Map<? extends AbstractNodeDescriptor,Integer> knownElements, int unknownElements) {

-                this.dataHash = calculateDataHash(knownElements,unknownElements)

-                this.unknownElements = unknownElements

-                this.knownElements = knownElements

-        }

-        

-        def private static calculateDataHash(Map<? extends AbstractNodeDescriptor,Integer> knownElements, int unknownElements)

-        {

-                val int prime = 31;

-                return knownElements.hashCode * prime + unknownElements.hashCode 

-        }

-}

-*/
\ No newline at end of file
+ * @Data

+ * class ModelDescriptor {

+ *      int dataHash

+ *      int unknownElements

+ *      Map<? extends AbstractNodeDescriptor,Integer> knownElements

+ *      

+ *      public new(Map<? extends AbstractNodeDescriptor,Integer> knownElements, int unknownElements) {

+ *              this.dataHash = calculateDataHash(knownElements,unknownElements)

+ *              this.unknownElements = unknownElements

+ *              this.knownElements = knownElements

+ *      }

+ *      

+ *      def private static calculateDataHash(Map<? extends AbstractNodeDescriptor,Integer> knownElements, int unknownElements)

+ *      {

+ *              val int prime = 31;

+ *              return knownElements.hashCode * prime + unknownElements.hashCode 

+ *      }

+ * }

+ */

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..efc89803
--- /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 FixPointRage = -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(GraphWidthRange, 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/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 d1bf0348..a0382e8e 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 hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation

+import java.util.ArrayList

 import java.util.HashMap

 import java.util.HashSet

-import java.util.LinkedList

 import java.util.List

 import java.util.Map

 import java.util.Set

 

 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 FixPointRage = NeighbourhoodOptions.FixPointRage

+        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,45 +55,50 @@ 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) 

-        {

+        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 Map<DefinedElement, Set<String>> types = new HashMap

-                fillTypes(model,types,relevantTypes)

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

-                

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

@@ -99,6 +111,7 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                         reachable.put(element, new HashSet)

                         newReachable.put(element, set)

                 }

+

                 var int width = 0

                 var boolean newAdded

                 do {

@@ -122,7 +135,6 @@ abstract class PartialInterpretation2NeighbourhoodRepresentation<ModelRepresenta
                 } while (newAdded)

                 return width

         }

-                

         /**

          * Creates a neighbourhood representation with traces

          * @param model The model to be represented.

@@ -131,68 +143,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

+                                return res

                 } else if (range == FixPointRage) {

-                        return refineUntilFixpoint(model,types,IncomingRelations,OutgoingRelations,parallels,maxNumber)

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

-                        

+                        hasRefined = nextNumberOfTypes > previousNumberOfTypes

+

                         lastRange = nextRange

                         lastRepresentation = nextRepresentation

-                        

+

 //                      if(hasRefined) {

 //                              println('''Level «nextRange» is calculated, number of types is refined: «previousNumberOfTypes» -> «nextNumberOfTypes»''')

 //                      } else {

@@ -201,211 +216,219 @@ 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) {

+

+        def private fillTypes(PartialInterpretation model, Map<DefinedElement, Set<String>> node2Type,

+                Set<TypeDeclaration> relevantTypes) {

+                for (element : model.elements) {

                         node2Type.put(element, new HashSet)

                 }

-                

+

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

                 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)

-        {               

+                DefinedElement object, Map<DefinedElement, ? extends NodeRepresentation> previousNodeRepresentations,

+                int parallel) {

                 val Map<IncomingRelation<NodeRepresentation>, Integer> res = new HashMap

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

+                                res.put(e, addOne(res.get(e), parallel))

                         } else {

                                 res.put(e, 1)

                         }

                 }

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

+

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

+                                res.put(e, 1)

                         }

                 }

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

-        {

+

+        private def calculateLocalNodeDescriptors(PartialInterpretation model, Map<DefinedElement, Set<String>> types,

+                int maxNumber, DefinedElement focusedElement) {

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

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

+                        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..4ff39999 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,86 @@
 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.PartialInterpretation2ImmutableTypeLattice
 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
-
-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(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
-        }*/
-        
-        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
+class NeighbourhoodBasedPartialInterpretationStateCoder extends AbstractNeighbourhoodBasedPartialInterpretationStateCoder {
+        val calculator = new PartialInterpretation2ImmutableTypeLattice
+
+        var Map<DefinedElement, ? extends AbstractNodeDescriptor> nodeRepresentations = null
+        var Map<? extends AbstractNodeDescriptor, Integer> modelRepresentation = null
+
+        new(NeighbourhoodOptions options) {
+                super(options)
         }
-    
-    @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
-                        } else {
-                                throw new UnsupportedOperationException('''Unsupported type: «o.class.simpleName»''')
+
+        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
+        }
+
+        override doCreateActivationCode(IPatternMatch match) {
+                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
                         }
-                } 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.fullyQualifiedName -> (res -> equivalenceHash).hashCode
+        }
+
+        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.reasoner/META-INF/MANIFEST.MF b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/META-INF/MANIFEST.MF
index 2a271acf..4ad61ccb 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/META-INF/MANIFEST.MF
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/META-INF/MANIFEST.MF
@@ -3,7 +3,8 @@ Bundle-ManifestVersion: 2
 Bundle-Name: Reasoner
 Bundle-SymbolicName: hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner
 Bundle-Version: 1.0.0.qualifier
-Export-Package: hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner
+Export-Package: hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
 Require-Bundle: hu.bme.mit.inf.dslreasoner.ecore2logic;bundle-version="1.0.0",
  hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0",
  hu.bme.mit.inf.dslreasoner.viatra2logic;bundle-version="1.0.0",
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasoner.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasoner.xtend
index 6639e5f3..1abde0a8 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasoner.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasoner.xtend
@@ -1,5 +1,7 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner

 

+import com.google.common.collect.ImmutableList

+import com.google.common.collect.Lists

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.DocumentationLevel

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasoner

 import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicReasonerException

@@ -10,19 +12,25 @@ 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.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.PairwiseNeighbourhoodBasedStateCoderFactory

 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.BestFirstStrategyForModelGeneration

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.DiversityChecker

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.InconsistentScopeGlobalConstraint

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.LoggerSolutionFoundHandler

 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.ModelGenerationCompositeObjective

 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.PartialModelAsLogicInterpretation

 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.ScopeObjective

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.SurelyViolatedObjectiveGlobalConstraint

 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.UnfinishedMultiplicityObjective

-import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.UnfinishedWFObjective

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.ViatraReasonerSolutionSaver

 import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.WF2ObjectiveConverter

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ThreeValuedCostElement

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ThreeValuedCostObjective

 import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace

 import java.util.List

 import java.util.Map

@@ -31,185 +39,247 @@ import org.eclipse.viatra.dse.api.DesignSpaceExplorer
 import org.eclipse.viatra.dse.api.DesignSpaceExplorer.DseLoggingLevel

 import org.eclipse.viatra.dse.solutionstore.SolutionStore

 import org.eclipse.viatra.dse.statecode.IStateCoderFactory

-import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.SolutionStoreWithDiversityDescriptor

-import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse.DiversityGranularity

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.statecoder.NeighbourhoodBasedStateCoderFactory

 

-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 ScopePropagator scopePropagator = new ScopePropagator(emptySolution)

-                scopePropagator.propagateAllScopeConstraints            

-                

+

                 val method = modelGenerationMethodProvider.createModelGenerationMethod(

                         problem,

                         emptySolution,

                         workspace,

                         viatraConfig.nameNewElements,

                         viatraConfig.typeInferenceMethod,

-                        scopePropagator,

+                        viatraConfig.scopePropagatorStrategy,

                         viatraConfig.documentationLevel

                 )

-                

+

                 dse.addObjective(new ModelGenerationCompositeObjective(

                         new ScopeObjective,

                         method.unfinishedMultiplicities.map[new UnfinishedMultiplicityObjective(it)],

-                        new UnfinishedWFObjective(method.unfinishedWF)

+                        wf2ObjectiveConverter.createCompletenessObjective(method.unfinishedWF)

                 ))

 

-                dse.addGlobalConstraint(wf2ObjectiveConverter.createInvalidationObjective(method.invalidWF))

-                for(additionalConstraint : viatraConfig.searchSpaceConstraints.additionalGlobalConstraints) {

+                val extremalObjectives = Lists.newArrayListWithExpectedSize(viatraConfig.costObjectives.size)

+                for (entry : viatraConfig.costObjectives.indexed) {

+                        val objectiveName = '''costObjective«entry.key»'''

+                        val objectiveConfig = entry.value

+                        val elementsBuilder = ImmutableList.builder

+                        for (elementConfig : objectiveConfig.elements) {

+                                val relationName = elementConfig.patternQualifiedName

+                                val modalQueries = method.modalRelationQueries.get(relationName)

+                                if (modalQueries === null) {

+                                        throw new IllegalArgumentException("Unknown relation: " + relationName)

+                                }

+                                elementsBuilder.add(new ThreeValuedCostElement(

+                                        modalQueries.currentQuery,

+                                        modalQueries.mayQuery,

+                                        modalQueries.mustQuery,

+                                        elementConfig.weight

+                                ))

+                        }

+                        val costElements = elementsBuilder.build

+                        val costObjective = new ThreeValuedCostObjective(objectiveName, costElements, objectiveConfig.kind,

+                                objectiveConfig.threshold, 3)

+                        dse.addObjective(costObjective)

+                        if (objectiveConfig.findExtremum) {

+                                extremalObjectives += costObjective

+                        }

+                }

+

+                val numberOfRequiredSolutions = configuration.solutionScope.numberOfRequiredSolutions

+                val solutionStore = if (extremalObjectives.empty) {

+                                new SolutionStore(numberOfRequiredSolutions)

+                        } else {

+                                new SolutionStore()

+                        }

+                solutionStore.registerSolutionFoundHandler(new LoggerSolutionFoundHandler(viatraConfig))

+                val diversityChecker = DiversityChecker.of(viatraConfig.diversityRequirement)

+                val solutionSaver = new ViatraReasonerSolutionSaver(newArrayList(extremalObjectives), numberOfRequiredSolutions,

+                        diversityChecker)

+                val solutionCopier = solutionSaver.solutionCopier

+                solutionStore.withSolutionSaver(solutionSaver)

+                dse.solutionStore = solutionStore

+

+                dse.addGlobalConstraint(wf2ObjectiveConverter.createInvalidationGlobalConstraint(method.invalidWF))

+                dse.addGlobalConstraint(new SurelyViolatedObjectiveGlobalConstraint(solutionSaver))

+                dse.addGlobalConstraint(new InconsistentScopeGlobalConstraint)

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

+                        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 BestFirstStrategyForModelGeneration(workspace,viatraConfig,method)

+

+                val strategy = new BestFirstStrategyForModelGeneration(workspace, viatraConfig, method)

                 viatraConfig.progressMonitor.workedForwardTransformation

-                

+

                 val transformationTime = System.nanoTime - 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

-                

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

                                 ]

                         }

                         it.entries += createIntStatisticEntry => [

-                                it.name = "TransformationExecutionTime" it.value = (method.statistics.transformationExecutionTime/1000000) as int

+                                it.name = "TransformationExecutionTime"

+                                it.value = (method.statistics.transformationExecutionTime / 1000000) as int

                         ]

                         it.entries += createIntStatisticEntry => [

-                                it.name = "TypeAnalysisTime" it.value = (method.statistics.PreliminaryTypeAnalisisTime/1000000) as int

+                                it.name = "ScopePropagationTime"

+                                it.value = (method.statistics.scopePropagationTime / 1000000) as int

                         ]

                         it.entries += createIntStatisticEntry => [

-                                it.name = "StateCoderTime" it.value = (statecoder.runtime/1000000) as int

+                                it.name = "TypeAnalysisTime"

+                                it.value = (method.statistics.preliminaryTypeAnalisisTime / 1000000) as int

                         ]

                         it.entries += createIntStatisticEntry => [

-                                it.name = "StateCoderFailCount" it.value = strategy.numberOfStatecoderFail

+                                it.name = "StateCoderTime"

+                                it.value = (statecoder.runtime / 1000000) as int

                         ]

                         it.entries += createIntStatisticEntry => [

-                                it.name = "SolutionCopyTime" it.value = (strategy.solutionStoreWithCopy.sumRuntime/1000000) as int

+                                it.name = "StateCoderFailCount"

+                                it.value = strategy.numberOfStatecoderFail

                         ]

-                        if(strategy.solutionStoreWithDiversityDescriptor.isActive) {

+                        it.entries += createIntStatisticEntry => [

+                                it.name = "SolutionCopyTime"

+                                it.value = (solutionCopier.getTotalCopierRuntime / 1000000) as int

+                        ]

+                        it.entries += createIntStatisticEntry => [

+                                it.name = "States"

+                                it.value = dse.numberOfStates as int

+                        ]

+                        it.entries += createIntStatisticEntry => [

+                                it.name = "Decisions"

+                                it.value = method.statistics.decisionsTried

+                        ]

+                        it.entries += createIntStatisticEntry => [

+                                it.name = "ScopePropagations"

+                                it.value = method.statistics.scopePropagatorInvocations

+                        ]

+                        if (diversityChecker.isActive) {

                                 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 c4d7e231..a5f42a5f 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasonerConfiguration.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/ViatraReasonerConfiguration.xtend
@@ -6,19 +6,27 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration

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

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

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedralScopePropagatorConstraints

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedralScopePropagatorSolver

+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagatorStrategy

 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualiser

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveKind

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.ObjectiveThreshold

 import java.util.LinkedList

 import java.util.List

 import java.util.Set

 import org.eclipse.xtext.xbase.lib.Functions.Function1

 

-public enum StateCoderStrategy {

-        Neighbourhood, NeighbourhoodWithEquivalence, IDBased, DefinedByDiversity

+enum StateCoderStrategy {

+        Neighbourhood,

+        PairwiseNeighbourhood,

+        NeighbourhoodWithEquivalence,

+        IDBased,

+        DefinedByDiversity

 }

 

-class ViatraReasonerConfiguration extends LogicSolverConfiguration{

-        //public var Iterable<PQuery> existingQueries

-        

+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

@@ -26,7 +34,7 @@ class ViatraReasonerConfiguration extends LogicSolverConfiguration{
          * Once per 1/randomBacktrackChance the search selects a random state.

          */

         public var int randomBacktrackChance = 20;

-        

+

         /**

          * Describes the required diversity between the solutions.

          * Null means that the solutions have to have different state codes only.

@@ -40,14 +48,19 @@ 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 ScopePropagatorStrategy scopePropagatorStrategy = new ScopePropagatorStrategy.Polyhedral(

+                PolyhedralScopePropagatorConstraints.Relational, PolyhedralScopePropagatorSolver.Clp)

+

+        public var List<CostObjectiveConfiguration> costObjectives = newArrayList

 }

 

-public class DiversityDescriptor {

+class DiversityDescriptor {

         public var ensureDiversity = false

         public static val FixPointRange = -1

         public var int range = FixPointRange

@@ -57,20 +70,31 @@ public class DiversityDescriptor {
         public var Set<RelationDeclaration> relevantRelations = null

 }

 

-public class DebugConfiguration {

-        public var logging = false

-        public var PartialInterpretationVisualiser partialInterpretatioVisualiser = null;

+class DebugConfiguration {

+        public var PartialInterpretationVisualiser partialInterpretatioVisualiser = null

         public var partalInterpretationVisualisationFrequency = 1

 }

 

-public class InternalConsistencyCheckerConfiguration {

+class InternalConsistencyCheckerConfiguration {

         public var LogicReasoner internalIncosnsitencyDetector = null

         public var LogicSolverConfiguration internalInconsistencDetectorConfiguration = null

         public var incternalConsistencyCheckingFrequency = 1

 }

 

-public class SearchSpaceConstraint {

+class SearchSpaceConstraint {

         public static val UNLIMITED_MAXDEPTH = Integer.MAX_VALUE

         public var int maxDepth = UNLIMITED_MAXDEPTH

         public var List<Function1<ModelGenerationMethod, ModelGenerationMethodBasedGlobalConstraint>> additionalGlobalConstraints = new LinkedList

-}
\ No newline at end of file
+}

+

+class CostObjectiveConfiguration {

+        public var List<CostObjectiveElementConfiguration> elements = newArrayList

+        public var ObjectiveKind kind

+        public var ObjectiveThreshold threshold

+        public var boolean findExtremum

+}

+

+class CostObjectiveElementConfiguration {

+        public var String patternQualifiedName

+        public var int weight

+}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/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 60f46033..5af7fc69 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
@@ -21,6 +21,7 @@ import java.util.PriorityQueue;
 import java.util.Random;

 

 import org.apache.log4j.Logger;

+import org.eclipse.emf.ecore.EObject;

 import org.eclipse.emf.ecore.util.EcoreUtil;

 import org.eclipse.viatra.dse.api.strategy.interfaces.IStrategy;

 import org.eclipse.viatra.dse.base.ThreadContext;

@@ -75,8 +76,6 @@ 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();

@@ -95,14 +94,9 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                 this.workspace = workspace;

                 this.configuration = configuration;

                 this.method = method;

+                //logger.setLevel(Level.DEBUG);

         }

         

-        public SolutionStoreWithCopy getSolutionStoreWithCopy() {

-                return solutionStoreWithCopy;

-        }

-        public SolutionStoreWithDiversityDescriptor getSolutionStoreWithDiversityDescriptor() {

-                return solutionStoreWithDiversityDescriptor;

-        }

         public int getNumberOfStatecoderFail() {

                 return numberOfStatecoderFail;

         }

@@ -121,9 +115,6 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                         matchers.add(matcher);

                 }

                 

-                this.solutionStoreWithCopy = new SolutionStoreWithCopy();

-                this.solutionStoreWithDiversityDescriptor = new SolutionStoreWithDiversityDescriptor(configuration.diversityRequirement);

-

                 final ObjectiveComparatorHelper objectiveComparatorHelper = context.getObjectiveComparatorHelper();

                 this.comparator = new Comparator<TrajectoryWithFitness>() {

                         @Override

@@ -146,13 +137,13 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                         return;

                 }

                 

-                final Fitness firstFittness = context.calculateFitness();

-                checkForSolution(firstFittness);

+                final Fitness firstfitness = context.calculateFitness();

+                solutionStore.newSolution(context);

                 

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

@@ -167,22 +158,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;

 //                      }

@@ -194,10 +185,11 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                                 final Object nextActivation = iterator.next();

 //                              if (!iterator.hasNext()) {

 //                                      logger.debug("Last untraversed activation of the state.");

-//                                      trajectoiresToExplore.remove(currentTrajectoryWithFittness);

+//                                      trajectoiresToExplore.remove(currentTrajectoryWithfitness);

 //                              }

                                 logger.debug("Executing new activation: " + nextActivation);

                                 context.executeAcitvationId(nextActivation);

+                                method.getStatistics().incrementDecisionCount();

 

                                 visualiseCurrentState();

 //                              for(ViatraQueryMatcher<? extends IPatternMatch> matcher : matchers) {

@@ -209,7 +201,7 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
 //                                      System.out.println("---------");

 //                              }

                                 

-                                boolean consistencyCheckResult = checkConsistency(currentTrajectoryWithFittness);

+                                boolean consistencyCheckResult = checkConsistency(currentTrajectoryWithfitness);

                                 if(consistencyCheckResult == true) { continue mainLoop; }

 

                                 if (context.isCurrentStateAlreadyTraversed()) {

@@ -220,38 +212,38 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                                         context.backtrack();

                                 } else {

                                         final Fitness nextFitness = context.calculateFitness();

-                                        checkForSolution(nextFitness);

+                                        solutionStore.newSolution(context);

                                         if (context.getDepth() > configuration.searchSpaceConstraints.maxDepth) {

                                                 logger.debug("Reached max depth.");

                                                 context.backtrack();

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

@@ -263,25 +255,13 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
                         activationIds = new ArrayList<Object>(context.getUntraversedActivationIds());

                         Collections.shuffle(activationIds);

                 } 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.");

-                        }

-                }

-        }

-

         @Override

         public void interruptStrategy() {

                 isInterrupted = true;

@@ -311,13 +291,16 @@ public class BestFirstStrategyForModelGeneration implements IStrategy {
         }       

 

         public void visualiseCurrentState() {

-                PartialInterpretationVisualiser partialInterpretatioVisualiser = configuration.debugCongiguration.partialInterpretatioVisualiser;

+                PartialInterpretationVisualiser partialInterpretatioVisualiser = configuration.debugConfiguration.partialInterpretatioVisualiser;

                 if(partialInterpretatioVisualiser != null && this.configuration.documentationLevel == DocumentationLevel.FULL && workspace != null) {

                         PartialInterpretation p = (PartialInterpretation) (context.getModel());

                         int id = ++numberOfPrintedModel;

-                        if (id % configuration.debugCongiguration.partalInterpretationVisualisationFrequency == 0) {

+                        if (id % configuration.debugConfiguration.partalInterpretationVisualisationFrequency == 0) {

                                 PartialInterpretationVisualisation visualisation = partialInterpretatioVisualiser.visualiseConcretization(p);

-                                visualisation.writeToFile(workspace, String.format("state%09d.png", id));

+                                logger.debug("Visualizing state: " + id + " (" + context.getDesignSpaceManager().getCurrentState() + ")");

+                                String name = String.format("state%09d", id);

+                                visualisation.writeToFile(workspace, name + ".png");

+                                workspace.writeModel((EObject) context.getModel(), name + ".xmi");

                         }

                 }

         }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/DiversityChecker.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/DiversityChecker.xtend
new file mode 100644
index 00000000..fb1b2066
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/DiversityChecker.xtend
@@ -0,0 +1,184 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse

+

+import com.google.common.collect.HashMultiset

+import com.google.common.collect.ImmutableSet

+import com.google.common.collect.Multiset

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.AbstractNodeDescriptor

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.NeighbourhoodWithTraces

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.neighbourhood.PartialInterpretation2ImmutableTypeLattice

+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation

+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.DiversityDescriptor

+import java.util.Collection

+import java.util.HashSet

+import java.util.Map

+import java.util.Set

+import org.eclipse.viatra.dse.base.ThreadContext

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

+

+interface DiversityChecker {

+        public static val NO_DIVERSITY_CHECKER = new DiversityChecker {

+                override isActive() {

+                        false

+                }

+

+                override getTotalRuntime() {

+                        0

+                }

+

+                override getSuccessRate() {

+                        1.0

+                }

+

+                override newSolution(ThreadContext threadContext, Object solutionId, Collection<Object> dominatedSolutionIds) {

+                        true

+                }

+        }

+

+        def boolean isActive()

+

+        def long getTotalRuntime()

+

+        def double getSuccessRate()

+

+        def boolean newSolution(ThreadContext threadContext, Object solutionId, Collection<Object> dominatedSolutionIds)

+

+        static def of(DiversityDescriptor descriptor) {

+                if (descriptor.ensureDiversity) {

+                        new NodewiseDiversityChecker(descriptor)

+                } else {

+                        NO_DIVERSITY_CHECKER

+                }

+        }

+}

+

+abstract class AbstractDiversityChecker implements DiversityChecker {

+        val DiversityDescriptor descriptor

+        val PartialInterpretation2ImmutableTypeLattice solutionCoder = new PartialInterpretation2ImmutableTypeLattice

+

+        @Accessors(PUBLIC_GETTER) var long totalRuntime = 0

+        var int allCheckCount = 0

+        var int successfulCheckCount = 0

+

+        protected new(DiversityDescriptor descriptor) {

+                if (!descriptor.ensureDiversity) {

+                        throw new IllegalArgumentException(

+                                "Diversity description should enforce diversity or NO_DIVERSITY_CHECKER should be used instead.")

+                }

+                this.descriptor = descriptor

+        }

+

+        override isActive() {

+                true

+        }

+

+        override getTotalRuntime() {

+                throw new UnsupportedOperationException("TODO: auto-generated method stub")

+        }

+

+        override getSuccessRate() {

+                (allCheckCount as double) / (successfulCheckCount as double)

+        }

+

+        override newSolution(ThreadContext threadContext, Object solutionId, Collection<Object> dominatedSolutionIds) {

+                val start = System.nanoTime

+                val model = threadContext.model as PartialInterpretation

+                val representation = solutionCoder.createRepresentation(model, descriptor.range, descriptor.parallels,

+                        descriptor.maxNumber, descriptor.relevantTypes, descriptor.relevantRelations)

+                val isDifferent = internalNewSolution(representation, solutionId, dominatedSolutionIds)

+                totalRuntime += System.nanoTime - start

+                allCheckCount++

+                if (isDifferent) {

+                        successfulCheckCount++

+                }

+                isDifferent

+        }

+

+        protected abstract def boolean internalNewSolution(

+                NeighbourhoodWithTraces<Map<? extends AbstractNodeDescriptor, Integer>, AbstractNodeDescriptor> representation,

+                Object solutionId, Collection<Object> dominatedSolutionIds)

+}

+

+class NodewiseDiversityChecker extends AbstractDiversityChecker {

+        var Multiset<Integer> nodeCodes = HashMultiset.create

+        val Map<Object, Set<Integer>> tracedNodeCodes = newHashMap

+

+        new(DiversityDescriptor descriptor) {

+                super(descriptor)

+        }

+

+        override protected internalNewSolution(

+                NeighbourhoodWithTraces<Map<? extends AbstractNodeDescriptor, Integer>, AbstractNodeDescriptor> representation,

+                Object solutionId, Collection<Object> dominatedSolutionIds) {

+                val nodeCodesInSolution = ImmutableSet.copyOf(representation.modelRepresentation.keySet.map[hashCode])

+                val remainingNodeCodes = if (dominatedSolutionIds.empty) {

+                                nodeCodes

+                        } else {

+                                getRemainingNodeCodes(dominatedSolutionIds)

+                        }

+                val hasNewCode = nodeCodesInSolution.exists[!remainingNodeCodes.contains(it)]

+                if (hasNewCode) {

+                        nodeCodes = remainingNodeCodes

+                        nodeCodes.addAll(nodeCodesInSolution)

+                        for (dominatedSolutionId : dominatedSolutionIds) {

+                                tracedNodeCodes.remove(dominatedSolutionId)

+                        }

+                        tracedNodeCodes.put(solutionId, nodeCodesInSolution)

+                }

+                hasNewCode

+        }

+

+        private def getRemainingNodeCodes(Collection<Object> dominatedSolutionIds) {

+                // TODO Optimize multiset operations.

+                val copyOfNodeCodes = HashMultiset.create(nodeCodes)

+                for (dominatedSolutionId : dominatedSolutionIds) {

+                        val dominatedModelCode = tracedNodeCodes.get(dominatedSolutionId)

+                        if (dominatedModelCode === null) {

+                                throw new IllegalArgumentException("Unknown dominated solution: " + dominatedSolutionId)

+                        }

+                        copyOfNodeCodes.removeAll(dominatedModelCode)

+                }

+                copyOfNodeCodes

+        }

+}

+

+class GraphwiseDiversityChecker extends AbstractDiversityChecker {

+        var Set<Integer> modelCodes = newHashSet

+        val Map<Object, Integer> tracedModelCodes = newHashMap

+

+        new(DiversityDescriptor descriptor) {

+                super(descriptor)

+        }

+

+        override protected internalNewSolution(

+                NeighbourhoodWithTraces<Map<? extends AbstractNodeDescriptor, Integer>, AbstractNodeDescriptor> representation,

+                Object solutionId, Collection<Object> dominatedSolutionIds) {

+                val modelCodeOfSolution = representation.modelRepresentation.hashCode

+                val remainingModelCodes = if (dominatedSolutionIds.empty) {

+                                modelCodes

+                        } else {

+                                getRemainingModelCodes(dominatedSolutionIds)

+                        }

+                val isNewCode = !remainingModelCodes.contains(modelCodeOfSolution)

+                if (isNewCode) {

+                        modelCodes = remainingModelCodes

+                        modelCodes += modelCodeOfSolution

+                        for (dominatedSolutionId : dominatedSolutionIds) {

+                                tracedModelCodes.remove(dominatedSolutionId)

+                        }

+                        tracedModelCodes.put(solutionId, modelCodeOfSolution)

+                }

+                isNewCode

+        }

+

+        private def getRemainingModelCodes(Collection<Object> dominatedSolutionIds) {

+                val copyOfModelCodes = new HashSet(modelCodes)

+                for (dominatedSolutionId : dominatedSolutionIds) {

+                        val dominatedModelCode = tracedModelCodes.get(dominatedSolutionId)

+                        if (dominatedModelCode === null) {

+                                throw new IllegalArgumentException("Unknown dominated solution: " + dominatedSolutionId)

+                        }

+                        copyOfModelCodes -= dominatedModelCode

+                }

+                copyOfModelCodes

+        }

+}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/DseUtils.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/DseUtils.xtend
new file mode 100644
index 00000000..3c2e3319
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/DseUtils.xtend
@@ -0,0 +1,66 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization.IThreeValuedObjective
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.objectives.Comparators
+import org.eclipse.viatra.dse.objectives.Fitness
+import org.eclipse.viatra.dse.objectives.IObjective
+
+final class DseUtils {
+        private new() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly.")
+        }
+
+        static def calculateFitness(ThreadContext it, (IObjective)=>Double getFitness) {
+                val result = new Fitness
+                var boolean satisifiesHardObjectives = true
+                for (objective : objectives) {
+                        val fitness = getFitness.apply(objective)
+                        result.put(objective.name, fitness)
+                        if (objective.isHardObjective() && !objective.satisifiesHardObjective(fitness)) {
+                                satisifiesHardObjectives = false
+                        }
+                }
+                result.satisifiesHardObjectives = satisifiesHardObjectives
+                result
+        }
+
+        static def caclulateBestPossibleFitness(ThreadContext threadContext) {
+                threadContext.calculateFitness [ objective |
+                        if (objective instanceof IThreeValuedObjective) {
+                                objective.getBestPossibleFitness(threadContext)
+                        } else {
+                                switch (objective.comparator) {
+                                        case Comparators.LOWER_IS_BETTER:
+                                                Double.NEGATIVE_INFINITY
+                                        case Comparators.HIGHER_IS_BETTER:
+                                                Double.POSITIVE_INFINITY
+                                        case Comparators.DIFFERENCE_TO_ZERO_IS_BETTER:
+                                                0.0
+                                        default:
+                                                throw new IllegalArgumentException("Unknown comparator for non-three-valued objective: " +
+                                                        objective.name)
+                                }
+                        }
+                ]
+        }
+
+        static def caclulateWorstPossibleFitness(ThreadContext threadContext) {
+                threadContext.calculateFitness [ objective |
+                        if (objective instanceof IThreeValuedObjective) {
+                                objective.getWorstPossibleFitness(threadContext)
+                        } else {
+                                switch (objective.comparator) {
+                                        case Comparators.LOWER_IS_BETTER,
+                                        case Comparators.DIFFERENCE_TO_ZERO_IS_BETTER:
+                                                Double.POSITIVE_INFINITY
+                                        case Comparators.HIGHER_IS_BETTER:
+                                                Double.NEGATIVE_INFINITY
+                                        default:
+                                                throw new IllegalArgumentException("Unknown comparator for non-three-valued objective: " +
+                                                        objective.name)
+                                }
+                        }
+                ]
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/InconsistentScopeGlobalConstraint.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/InconsistentScopeGlobalConstraint.xtend
new file mode 100644
index 00000000..2e039ca2
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/InconsistentScopeGlobalConstraint.xtend
@@ -0,0 +1,25 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+
+import org.eclipse.viatra.dse.objectives.IGlobalConstraint
+import org.eclipse.viatra.dse.base.ThreadContext
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+
+class InconsistentScopeGlobalConstraint implements IGlobalConstraint {
+
+        override init(ThreadContext context) {
+                // Nothing to initialize.
+        }
+
+        override createNew() {
+                this
+        }
+
+        override getName() {
+                class.name
+        }
+
+        override checkGlobalConstraint(ThreadContext context) {
+                val partialModel = context.model as PartialInterpretation
+                partialModel.minNewElements <= partialModel.maxNewElements || partialModel.maxNewElements < 0
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/LoggerSolutionFoundHandler.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/LoggerSolutionFoundHandler.xtend
new file mode 100644
index 00000000..39ef5f9a
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/LoggerSolutionFoundHandler.xtend
@@ -0,0 +1,24 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration
+import org.apache.log4j.Logger
+import org.eclipse.viatra.dse.api.SolutionTrajectory
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.solutionstore.ISolutionFoundHandler
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+@FinalFieldsConstructor
+class LoggerSolutionFoundHandler implements ISolutionFoundHandler {
+        val ViatraReasonerConfiguration configuration
+
+        val logger = Logger.getLogger(SolutionCopier)
+
+        override solutionFound(ThreadContext context, SolutionTrajectory trajectory) {
+                configuration.progressMonitor.workedModelFound(configuration.solutionScope.numberOfRequiredSolutions)
+                logger.debug("Found a solution.")
+        }
+
+        override solutionTriedToSave(ThreadContext context, SolutionTrajectory trajectory) {
+                // We are not interested in invalid solutions, ignore.
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend
index 2489c751..9a33753c 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,11 +1,13 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse

 

+import com.google.common.collect.ImmutableList

+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 org.eclipse.xtend.lib.annotations.FinalFieldsConstructor

 

 //class ViatraReasonerNumbers {

 //      public static val scopePriority = 2

@@ -22,64 +24,66 @@ import org.eclipse.viatra.dse.objectives.impl.BaseObjective
 //      public static val compositePriority = 2

 //}

 

-class ModelGenerationCompositeObjective implements IObjective{

-        val ScopeObjective scopeObjective

-        val List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives

-        val UnfinishedWFObjective unfinishedWFObjective

-        

-        public new(

-                ScopeObjective scopeObjective,

-                List<UnfinishedMultiplicityObjective> unfinishedMultiplicityObjectives,

-                UnfinishedWFObjective unfinishedWFObjective)

-        {

-                this.scopeObjective = scopeObjective

-                this.unfinishedMultiplicityObjectives = unfinishedMultiplicityObjectives

-                this.unfinishedWFObjective = unfinishedWFObjective

-        }

-        

+@FinalFieldsConstructor

+class ModelGenerationCompositeObjective implements IThreeValuedObjective {

+        val IObjective scopeObjective

+        val List<IObjective> unfinishedMultiplicityObjectives

+        val IObjective unfinishedWFObjective

+

         override init(ThreadContext context) {

                 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)

+                        scopeObjective.createNew,

+                        ImmutableList.copyOf(unfinishedMultiplicityObjectives.map[createNew]),

+                        unfinishedWFObjective.createNew

+                )

         }

-        

+

         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 unfinishedMultiplicitiesFitneses = unfinishedMultiplicityObjectives.map[x|x.getFitness(context)]

                 val unfinishedWFsFitness = unfinishedWFObjective.getFitness(context)

-                

-                sum+=scopeFitnes

+

+                sum += scopeFitnes

                 var multiplicity = 0.0

-                for(multiplicityObjective : unfinishedMultiplicityObjectives) {

-                        multiplicity+=multiplicityObjective.getFitness(context)//*0.5

+                for (multiplicityObjective : unfinishedMultiplicityObjectives) {

+                        multiplicity += multiplicityObjective.getFitness(context) // *0.5

                 }

-                sum+=multiplicity

-                sum += unfinishedWFsFitness//*0.5

-                

-                //println('''Sum=«sum»|Scope=«scopeFitnes»|Multiplicity=«multiplicity»|WFs=«unfinishedWFsFitness»''')

-                

+                sum += multiplicity

+                sum += unfinishedWFsFitness // *0.5

+                // println('''Sum=«sum»|Scope=«scopeFitnes»|Multiplicity=«multiplicity»|WFs=«unfinishedWFsFitness»''')

                 return sum

         }

         

-        override getLevel() { 2 }

-        override getName() { "CompositeUnfinishednessObjective"}

+        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 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/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..d036257d
--- /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,74 @@
+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
+}
+
+class SolutionCopier {
+        val copiedSolutions = new LinkedHashMap<Object, CopiedSolution>
+
+        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)
+                        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
deleted file mode 100644
index a8b7301e..00000000
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/SolutionStoreWithCopy.xtend
+++ /dev/null
@@ -1,52 +0,0 @@
-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.Map

-import org.eclipse.emf.ecore.util.EcoreUtil

-import org.eclipse.viatra.dse.base.ThreadContext

-import java.util.TreeMap

-import java.util.SortedMap

-

-class SolutionStoreWithCopy {

-        

-        long runtime = 0

-        List<PartialInterpretation> solutions = new LinkedList

-        //public List<SortedMap<String,Integer>> additionalMatches = new LinkedList

-        List<Map<EObject,EObject>> copyTraces = new LinkedList

-        

-        long sartTime = System.nanoTime

-        List<Long> solutionTimes = new LinkedList

-        

-        /*def newSolution(ThreadContext context, SortedMap<String,Integer> additonalMatch) {

-                additionalMatches+= additonalMatch

-                newSolution(context)

-        }*/

-        

-        def newSolution(ThreadContext context) {

-                //print(System.nanoTime-initTime + ";")

-                val copyStart = System.nanoTime

-                val solution = context.model as PartialInterpretation

-                val copier = new EcoreUtil.Copier

-                val solutionCopy = copier.copy(solution) as PartialInterpretation

-                copier.copyReferences

-                solutions.add(solutionCopy)

-                copyTraces.add(copier)

-                runtime += System.nanoTime - copyStart

-                solutionTimes.add(System.nanoTime-sartTime)

-        }

-        def getSumRuntime() {

-                return runtime

-        }

-        def getAllRuntimes() {

-                return solutionTimes

-        }

-        def getSolutions() {

-                solutions

-        }

-        def getCopyTraces() {

-                return copyTraces

-        }

-}
\ 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/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..9f0c642f 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;

         

-        public new(MultiplicityGoalConstraintCalculator unfinishedMultiplicity) {

+        new(MultiplicityGoalConstraintCalculator unfinishedMultiplicity) {

                 this.unfinishedMultiplicity = unfinishedMultiplicity

         }

         

@@ -29,9 +29,9 @@ 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

         }

-}
\ 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..bf34aeeb 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,23 +1,21 @@
 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)

         }

@@ -48,9 +46,9 @@ class UnfinishedWFObjective 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()

         }

 }
\ 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..6bffeb59
--- /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,137 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.dse
+
+import java.util.HashMap
+import java.util.Map
+import org.eclipse.viatra.dse.api.DSEException
+import org.eclipse.viatra.dse.api.Solution
+import org.eclipse.viatra.dse.api.SolutionTrajectory
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.objectives.Fitness
+import org.eclipse.viatra.dse.objectives.IObjective
+import org.eclipse.viatra.dse.objectives.ObjectiveComparatorHelper
+import org.eclipse.viatra.dse.solutionstore.SolutionStore.ISolutionSaver
+import org.eclipse.xtend.lib.annotations.Accessors
+
+/**
+ * Based on {@link SolutionStore.BestSolutionSaver}.
+ */
+class ViatraReasonerSolutionSaver implements ISolutionSaver {
+        @Accessors val solutionCopier = new SolutionCopier
+        @Accessors val DiversityChecker diversityChecker
+        val boolean hasExtremalObjectives
+        val int numberOfRequiredSolutions
+        val ObjectiveComparatorHelper comparatorHelper
+        val Map<SolutionTrajectory, Fitness> trajectories = new HashMap
+
+        @Accessors(PUBLIC_SETTER) var Map<Object, Solution> solutionsCollection
+
+        new(IObjective[][] leveledExtremalObjectives, int numberOfRequiredSolutions, DiversityChecker diversityChecker) {
+                this.diversityChecker = diversityChecker
+                comparatorHelper = new ObjectiveComparatorHelper(leveledExtremalObjectives)
+                hasExtremalObjectives = leveledExtremalObjectives.exists[!empty]
+                this.numberOfRequiredSolutions = numberOfRequiredSolutions
+        }
+
+        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 (!fitness.satisifiesHardObjectives) {
+                        return false
+                }
+                val dominatedTrajectories = newArrayList
+                for (entry : trajectories.entrySet) {
+                        val isLastFitnessBetter = comparatorHelper.compare(fitness, entry.value)
+                        if (isLastFitnessBetter < 0) {
+                                // Found a trajectory that dominates the current one, no need to save
+                                return false
+                        }
+                        if (isLastFitnessBetter > 0) {
+                                dominatedTrajectories += entry.key
+                        }
+                }
+                if (dominatedTrajectories.size == 0 && !needsMoreSolutionsWithSameFitness) {
+                        return false
+                }
+                if (!diversityChecker.newSolution(context, id, dominatedTrajectories.map[solution.stateCode])) {
+                        return false
+                }
+                // We must save the new trajectory before removing dominated trajectories
+                // to avoid removing the current solution when it is reachable only via dominated trajectories.
+                val solutionSaved = basicSaveSolution(context, id, solutionTrajectory, fitness)
+                for (dominatedTrajectory : dominatedTrajectories) {
+                        trajectories -= dominatedTrajectory
+                        val dominatedSolution = dominatedTrajectory.solution
+                        if (!dominatedSolution.trajectories.remove(dominatedTrajectory)) {
+                                throw new DSEException(
+                                        "Dominated solution is not reachable from dominated trajectory. This should never happen!")
+                        }
+                        if (dominatedSolution.trajectories.empty) {
+                                val dominatedSolutionId = dominatedSolution.stateCode
+                                solutionCopier.markAsObsolete(dominatedSolutionId)
+                                solutionsCollection -= dominatedSolutionId
+                        }
+                }
+                solutionSaved
+        }
+
+        private def saveAnyDiverseSolution(ThreadContext context, Object id, SolutionTrajectory solutionTrajectory) {
+                val fitness = context.lastFitness
+                if (!fitness.satisifiesHardObjectives) {
+                        return false
+                }
+                if (!diversityChecker.newSolution(context, id, emptyList)) {
+                        return false
+                }
+                basicSaveSolution(context, id, solutionTrajectory, fitness)
+        }
+
+        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
+        }
+}
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..63d78220 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,35 @@ import org.eclipse.viatra.query.runtime.api.IQuerySpecification
 import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher

 

 class WF2ObjectiveConverter {

-        

+        static val UNFINISHED_WFS_NAME = "unfinishedWFs"

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

+                // createConstraintObjective(UNFINISHED_WFS_NAME, 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/DirectionalThresholdObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/DirectionalThresholdObjective.xtend
new file mode 100644
index 00000000..376e3d1a
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/DirectionalThresholdObjective.xtend
@@ -0,0 +1,164 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import java.util.Comparator
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.objectives.IObjective
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.Data
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+abstract class ObjectiveThreshold {
+        public static val NO_THRESHOLD = new ObjectiveThreshold {
+                override isHard() {
+                        false
+                }
+
+                override satisfiesThreshold(double cost, Comparator<Double> comparator) {
+                        true
+                }
+
+                override protected postProcessSatisfactoryCost(double cost, ObjectiveKind kind) {
+                        cost
+                }
+
+                override ObjectiveThreshold merge(ObjectiveThreshold other) {
+                        if (other == NO_THRESHOLD) {
+                                NO_THRESHOLD
+                        } else {
+                                throw new IllegalArgumentException("Merged thresholds must have the same type")
+                        }
+                }
+        }
+
+        private new() {
+        }
+
+        def boolean isHard() {
+                true
+        }
+
+        def boolean satisfiesThreshold(double cost, ObjectiveKind kind) {
+                satisfiesThreshold(cost, kind.comparator)
+        }
+
+        def boolean satisfiesThreshold(double cost, Comparator<Double> comparator)
+
+        def double postProcessCost(double cost, ObjectiveKind kind) {
+                if (satisfiesThreshold(cost, kind)) {
+                        postProcessSatisfactoryCost(cost, kind)
+                } else {
+                        cost
+                }
+        }
+
+        protected def double postProcessSatisfactoryCost(double cost, ObjectiveKind kind)
+
+        def ObjectiveThreshold merge(ObjectiveThreshold other)
+
+        @Data
+        static class Exclusive extends ObjectiveThreshold {
+                static val EPSILON = 0.1
+
+                val double threshold
+                val boolean clampToThreshold
+
+                @FinalFieldsConstructor
+                new() {
+                }
+
+                new(double threshold) {
+                        this(threshold, true)
+                }
+
+                override satisfiesThreshold(double cost, Comparator<Double> comparator) {
+                        comparator.compare(threshold, cost) < 0
+                }
+
+                override protected postProcessSatisfactoryCost(double cost, ObjectiveKind kind) {
+                        if (clampToThreshold) {
+                                threshold + Math.signum(kind.satisfiedValue) * EPSILON
+                        } else {
+                                cost
+                        }
+                }
+
+                override ObjectiveThreshold merge(ObjectiveThreshold other) {
+                        if (other instanceof Exclusive) {
+                                new Exclusive(threshold + other.threshold)
+                        } else {
+                                throw new IllegalArgumentException("Merged thresholds must have the same type")
+                        }
+                }
+        }
+
+        @Data
+        static class Inclusive extends ObjectiveThreshold {
+                val double threshold
+                val boolean clampToThreshold
+
+                @FinalFieldsConstructor
+                new() {
+                }
+
+                new(double threshold) {
+                        this(threshold, true)
+                }
+
+                override satisfiesThreshold(double cost, Comparator<Double> comparator) {
+                        comparator.compare(threshold, cost) <= 0
+                }
+
+                override protected postProcessSatisfactoryCost(double cost, ObjectiveKind kind) {
+                        if (clampToThreshold) {
+                                threshold
+                        } else {
+                                cost
+                        }
+                }
+                
+                override ObjectiveThreshold merge(ObjectiveThreshold other) {
+                        if (other instanceof Inclusive) {
+                                new Inclusive(threshold + other.threshold)
+                        } else {
+                                throw new IllegalArgumentException("Merged thresholds must have the same type")
+                        }
+                }
+        }
+}
+
+abstract class DirectionalThresholdObjective implements IObjective {
+        @Accessors val String name
+        @Accessors ObjectiveKind kind
+        @Accessors ObjectiveThreshold threshold
+        @Accessors int level
+
+        protected new(String name, ObjectiveKind kind, ObjectiveThreshold threshold, int level) {
+                this.name = name
+                this.kind = kind
+                this.threshold = threshold
+                this.level = level
+        }
+
+        override isHardObjective() {
+                threshold.hard
+        }
+
+        override satisifiesHardObjective(Double fitness) {
+                threshold.satisfiesThreshold(fitness, comparator)
+        }
+
+        override getComparator() {
+                kind.comparator
+        }
+
+        override setComparator(Comparator<Double> comparator) {
+                kind = ObjectiveKind.fromComparator(comparator)
+        }
+
+        override getFitness(ThreadContext context) {
+                val fitness = getRawFitness(context)
+                threshold.postProcessCost(fitness, kind)
+        }
+
+        protected def double getRawFitness(ThreadContext context)
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IThreeValuedObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IThreeValuedObjective.xtend
new file mode 100644
index 00000000..4a870a3e
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IThreeValuedObjective.xtend
@@ -0,0 +1,10 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.objectives.IObjective
+
+interface IThreeValuedObjective extends IObjective {
+        def Double getWorstPossibleFitness(ThreadContext threadContext)
+        
+        def Double getBestPossibleFitness(ThreadContext threadContext)
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/MatchCostObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/MatchCostObjective.xtend
new file mode 100644
index 00000000..a0c6a2c1
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/MatchCostObjective.xtend
@@ -0,0 +1,52 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import com.google.common.collect.ImmutableList
+import java.util.Collection
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.xtend.lib.annotations.Data
+
+@Data
+class MatchCostElement {
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> querySpecification
+        val double weight
+}
+
+class MatchCostObjective extends DirectionalThresholdObjective {
+        val Collection<MatchCostElement> costElements
+        Collection<CostElementMatcher> matchers
+
+        new(String name, Collection<MatchCostElement> costElements, ObjectiveKind kind, ObjectiveThreshold threshold,
+                int level) {
+                super(name, kind, threshold, level)
+                this.costElements = costElements
+        }
+
+        override createNew() {
+                new MatchCostObjective(name, costElements, kind, threshold, level)
+        }
+
+        override init(ThreadContext context) {
+                val queryEngine = context.queryEngine
+                matchers = ImmutableList.copyOf(costElements.map [
+                        val matcher = querySpecification.getMatcher(queryEngine)
+                        new CostElementMatcher(matcher, weight)
+                ])
+        }
+
+        override protected getRawFitness(ThreadContext context) {
+                var double cost = 0
+                for (it : matchers) {
+                        cost += weight * matcher.countMatches
+                }
+                cost
+        }
+
+        @Data
+        private static class CostElementMatcher {
+                val ViatraQueryMatcher<? extends IPatternMatch> matcher
+                val double weight
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ObjectiveKind.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ObjectiveKind.java
new file mode 100644
index 00000000..cbbaaafd
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ObjectiveKind.java
@@ -0,0 +1,60 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization;
+
+import java.util.Comparator;
+
+import org.eclipse.viatra.dse.objectives.Comparators;
+
+public enum ObjectiveKind {
+        LOWER_IS_BETTER {
+
+                @Override
+                public Comparator<Double> getComparator() {
+                        return Comparators.LOWER_IS_BETTER;
+                }
+
+                @Override
+                public double getInvalidValue() {
+                        return Double.POSITIVE_INFINITY;
+                }
+
+                @Override
+                public double getSatisfiedValue() {
+                        return Double.NEGATIVE_INFINITY;
+                }
+
+        },
+        HIGHER_IS_BETTER {
+
+                @Override
+                public Comparator<Double> getComparator() {
+                        return Comparators.HIGHER_IS_BETTER;
+                }
+
+                @Override
+                public double getInvalidValue() {
+                        return Double.NEGATIVE_INFINITY;
+                }
+
+                @Override
+                public double getSatisfiedValue() {
+                        return Double.POSITIVE_INFINITY;
+                }
+
+        };
+
+        public abstract Comparator<Double> getComparator();
+
+        public abstract double getInvalidValue();
+
+        public abstract double getSatisfiedValue();
+
+        public static ObjectiveKind fromComparator(Comparator<Double> comparator) {
+                if (Comparators.LOWER_IS_BETTER.equals(comparator)) {
+                        return ObjectiveKind.LOWER_IS_BETTER;
+                } else if (Comparators.HIGHER_IS_BETTER.equals(comparator)) {
+                        return ObjectiveKind.HIGHER_IS_BETTER;
+                } else {
+                        throw new IllegalStateException("Only LOWER_IS_BETTER and HIGHER_IS_BETTER comparators are supported.");
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/QueryBasedObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/QueryBasedObjective.xtend
new file mode 100644
index 00000000..d355f5be
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/QueryBasedObjective.xtend
@@ -0,0 +1,48 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+
+class QueryBasedObjective extends DirectionalThresholdObjective {
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> querySpecification
+        ViatraQueryMatcher<? extends IPatternMatch> matcher
+
+        new(IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> querySpecification,
+                ObjectiveKind kind, ObjectiveThreshold threshold, int level) {
+                super(querySpecification.simpleName + " objective", kind, threshold, level)
+                if (querySpecification.parameters.size != 1) {
+                        throw new IllegalArgumentException("Objective query must have a single parameter")
+                }
+                this.querySpecification = querySpecification
+        }
+
+        override createNew() {
+                new QueryBasedObjective(querySpecification, kind, threshold, level)
+        }
+
+        override init(ThreadContext context) {
+                matcher = querySpecification.getMatcher(context.queryEngine)
+        }
+
+        override protected getRawFitness(ThreadContext context) {
+                val iterator = matcher.allMatches.iterator
+                if (!iterator.hasNext) {
+                        return invalidValue
+                }
+                val value = iterator.next.get(0)
+                if (iterator.hasNext) {
+                        throw new IllegalStateException("Multiple matches for objective query")
+                }
+                if (value instanceof Number) {
+                        value.doubleValue
+                } else {
+                        throw new IllegalStateException("Objective value is not an instance of Number")
+                }
+        }
+
+        private def getInvalidValue() {
+                kind.invalidValue
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjective.xtend
new file mode 100644
index 00000000..0a6fd55b
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjective.xtend
@@ -0,0 +1,85 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import com.google.common.collect.ImmutableList
+import java.util.Collection
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.xtend.lib.annotations.Data
+
+@Data
+class ThreeValuedCostElement {
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> currentMatchQuery
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> mayMatchQuery
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> mustMatchQuery
+        val int weight
+}
+
+class ThreeValuedCostObjective extends AbstractThreeValuedObjective {
+        val Collection<ThreeValuedCostElement> costElements
+        Collection<CostElementMatchers> matchers
+
+        new(String name, Collection<ThreeValuedCostElement> costElements, ObjectiveKind kind, ObjectiveThreshold threshold,
+                int level) {
+                super(name, kind, threshold, level)
+                this.costElements = costElements
+        }
+
+        override createNew() {
+                new ThreeValuedCostObjective(name, costElements, kind, threshold, level)
+        }
+
+        override init(ThreadContext context) {
+                val queryEngine = context.queryEngine
+                matchers = ImmutableList.copyOf(costElements.map [ element |
+                        new CostElementMatchers(
+                                queryEngine.getMatcher(element.currentMatchQuery),
+                                queryEngine.getMatcher(element.mayMatchQuery),
+                                queryEngine.getMatcher(element.mustMatchQuery),
+                                element.weight
+                        )
+                ])
+        }
+
+        override getRawFitness(ThreadContext context) {
+                var int cost = 0
+                for (matcher : matchers) {
+                        cost += matcher.weight * matcher.currentMatcher.countMatches
+                }
+                cost as double
+        }
+
+        override getLowestPossibleFitness(ThreadContext threadContext) {
+                var int cost = 0
+                for (matcher : matchers) {
+                        if (matcher.weight >= 0) {
+                                cost += matcher.weight * matcher.mustMatcher.countMatches
+                        } else if (matcher.mayMatcher.countMatches > 0) {
+                                // TODO Count may matches.
+                                return Double.NEGATIVE_INFINITY
+                        }
+                }
+                cost as double
+        }
+
+        override getHighestPossibleFitness(ThreadContext threadContext) {
+                var int cost = 0
+                for (matcher : matchers) {
+                        if (matcher.weight <= 0) {
+                                cost += matcher.weight * matcher.mustMatcher.countMatches
+                        } else if (matcher.mayMatcher.countMatches > 0) {
+                                return Double.POSITIVE_INFINITY
+                        }
+                }
+                cost as double
+        }
+
+        @Data
+        private static class CostElementMatchers {
+                val ViatraQueryMatcher<? extends IPatternMatch> currentMatcher
+                val ViatraQueryMatcher<? extends IPatternMatch> mayMatcher
+                val ViatraQueryMatcher<? extends IPatternMatch> mustMatcher
+                val int weight
+        }
+}