39 files changed, 5387 insertions, 928 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..e45ec1c8 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend
@@ -1,8 +1,20 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra

 

+import com.google.common.collect.ImmutableMap

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -10,6 +22,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 +33,112 @@ 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 transformationInvocations

+        

+        synchronized def incrementTransformationCount() {

+                transformationInvocations++

+        }

+

+        public var int scopePropagatorInvocations

+

+        synchronized def incrementScopePropagationCount() {

+                scopePropagatorInvocations++

+        }

+        

+        public var int scopePropagatorSolverInvocations

+

+        synchronized def incrementScopePropagationSolverCount() {

+                scopePropagatorSolverInvocations++

         }

-        public var long PreliminaryTypeAnalisisTime = 0

 }

+

 @Data class ModelGenerationMethod {

-         ModelGenerationStatistics statistics

-         

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

+                Collection<LinearTypeConstraintHint> hints,

                 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, hints, writeFiles)

+                val scopePropagator = createScopePropagator(scopePropagatorStrategy, emptySolution, hints, 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 +146,45 @@ class ModelGenerationMethodProvider {
                         unfinishedMultiplicities,

                         unfinishedWF,

                         invalidWF,

+                        modalRelationQueries,

                         queries.allQueries

                 )

         }

+

+        private def createScopePropagator(ScopePropagatorStrategy scopePropagatorStrategy,

+                PartialInterpretation emptySolution, Collection<LinearTypeConstraintHint> hints, GeneratedPatterns queries,

+                ModelGenerationStatistics statistics) {

+                if (!hints.empty && !(scopePropagatorStrategy instanceof ScopePropagatorStrategy.Polyhedral)) {

+                        throw new IllegalArgumentException("Only the Polyhedral scope propagator strategy can use hints.")

+                }

+                switch (scopePropagatorStrategy) {

+                        case ScopePropagatorStrategy.None,

+                        case ScopePropagatorStrategy.Basic:

+                                new ScopePropagator(emptySolution, statistics)

+                        case ScopePropagatorStrategy.BasicTypeHierarchy:

+                                new TypeHierarchyScopePropagator(emptySolution, statistics)

+                        ScopePropagatorStrategy.Polyhedral: {

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

+                                val allPatternsByName = queries.allQueries.toMap[fullyQualifiedName]

+                                val solver = switch (scopePropagatorStrategy.solver) {

+                                        case Z3Integer:

+                                                new Z3PolyhedronSolver(false, scopePropagatorStrategy.timeoutSeconds)

+                                        case Z3Real:

+                                                new Z3PolyhedronSolver(true, scopePropagatorStrategy.timeoutSeconds)

+                                        case Cbc:

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

+                                        case Clp:

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

+                                        default:

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

+                                                        scopePropagatorStrategy.solver)

+                                }

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

+                                        queries.hasElementInContainmentQuery, allPatternsByName, hints, solver,

+                                        scopePropagatorStrategy.requiresUpperBoundIndexing, scopePropagatorStrategy.updateHeuristic)

+                        }

+                        default:

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

+                }

+        }

 }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ScopePropagator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ScopePropagator.xtend
deleted file mode 100644
index 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..75c396b4
--- /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,237 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.ImmutableMap
+import hu.bme.mit.inf.dslreasoner.ilp.cbc.CbcResult
+import hu.bme.mit.inf.dslreasoner.ilp.cbc.CbcSolver
+import java.util.HashSet
+import java.util.List
+import java.util.Map
+import java.util.Set
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+@FinalFieldsConstructor
+class CbcPolyhedronSolver implements PolyhedronSolver {
+        val boolean lpRelaxation
+        val double timeoutSeconds
+        val boolean silent
+
+        new() {
+                this(false, -1, true)
+        }
+
+        override createSaturationOperator(Polyhedron polyhedron) {
+                new CbcSaturationOperator(polyhedron, lpRelaxation, timeoutSeconds, silent)
+        }
+}
+
+class CbcSaturationOperator extends AbstractPolyhedronSaturationOperator {
+        static val EPSILON = 1e-6
+
+        val boolean lpRelaxation
+        val double timeoutSeconds
+        val boolean silent
+        val double[] columnLowerBounds
+        val double[] columnUpperBounds
+        val double[] objective
+        val Map<Dimension, Integer> dimensionsToIndicesMap
+
+        new(Polyhedron polyhedron, boolean lpRelaxation, double timeoutSeconds, boolean silent) {
+                super(polyhedron)
+                this.lpRelaxation = lpRelaxation
+                this.timeoutSeconds = timeoutSeconds
+                this.silent = silent
+                val numDimensions = polyhedron.dimensions.size
+                columnLowerBounds = newDoubleArrayOfSize(numDimensions)
+                columnUpperBounds = newDoubleArrayOfSize(numDimensions)
+                objective = newDoubleArrayOfSize(numDimensions)
+                dimensionsToIndicesMap = ImmutableMap.copyOf(polyhedron.dimensions.indexed.toMap([value], [key]))
+        }
+
+        override doSaturate() {
+                val numDimensions = polyhedron.dimensions.size
+                for (var int j = 0; j < numDimensions; j++) {
+                        val dimension = polyhedron.dimensions.get(j)
+                        columnLowerBounds.set(j, dimension.lowerBound.toDouble(Double.NEGATIVE_INFINITY))
+                        columnUpperBounds.set(j, dimension.upperBound.toDouble(Double.POSITIVE_INFINITY))
+                }
+                val constraints = nonTrivialConstraints
+                val numConstraints = constraints.size
+                val rowStarts = newIntArrayOfSize(numConstraints + 1)
+                val rowLowerBounds = newDoubleArrayOfSize(numConstraints)
+                val rowUpperBounds = newDoubleArrayOfSize(numConstraints)
+                val numEntries = constraints.map[coefficients.size].reduce[a, b|a + b] ?: 0
+                rowStarts.set(numConstraints, numEntries)
+                val columnIndices = newIntArrayOfSize(numEntries)
+                val entries = newDoubleArrayOfSize(numEntries)
+                val unconstrainedDimensions = new HashSet
+                for (dimension : polyhedron.dimensions) {
+                        if (dimension.lowerBound === null && dimension.upperBound === null) {
+                                unconstrainedDimensions += dimension
+                        }
+                }
+                var int index = 0
+                for (var int i = 0; i < numConstraints; i++) {
+                        rowStarts.set(i, index)
+                        val constraint = constraints.get(i)
+                        rowLowerBounds.set(i, constraint.lowerBound.toDouble(Double.NEGATIVE_INFINITY))
+                        rowUpperBounds.set(i, constraint.upperBound.toDouble(Double.POSITIVE_INFINITY))
+                        if (!dimensionsToIndicesMap.keySet.containsAll(constraint.coefficients.keySet)) {
+                                throw new IllegalArgumentException("Constrains has unknown dimensions")
+                        }
+                        for (var int j = 0; j < numDimensions; j++) {
+                                val dimension = polyhedron.dimensions.get(j)
+                                val coefficient = constraint.coefficients.get(dimension)
+                                if (coefficient !== null && coefficient != 0) {
+                                        unconstrainedDimensions -= dimension
+                                        columnIndices.set(index, j)
+                                        entries.set(index, coefficient)
+                                        index++
+                                }
+                        }
+                }
+                if (index != numEntries) {
+                        throw new AssertionError("Last entry does not equal the number of entries in the constraint matrix")
+                }
+                for (expressionToSaturate : polyhedron.expressionsToSaturate) {
+                        val result = saturate(expressionToSaturate, rowStarts, columnIndices, entries, rowLowerBounds,
+                                rowUpperBounds, unconstrainedDimensions, constraints)
+                        if (result != PolyhedronSaturationResult.SATURATED) {
+                                return result
+                        }
+                }
+                PolyhedronSaturationResult.SATURATED
+        }
+
+        protected def saturate(LinearBoundedExpression expressionToSaturate, int[] rowStarts, int[] columnIndices,
+                double[] entries, double[] rowLowerBounds, double[] rowUpperBounds, Set<Dimension> unconstrainedDimensions,
+                ImmutableList<LinearConstraint> constraints) {
+                val numDimensions = objective.size
+                for (var int j = 0; j < numDimensions; j++) {
+                        objective.set(j, 0)
+                }
+                switch (expressionToSaturate) {
+                        Dimension: {
+                                // CBC will return nonsensical results or call free() with invalid arguments if
+                                // it is passed a fully unconstrained (-Inf lower and +Int upper bound, no inequalities) variable
+                                // in the objective function.
+                                if (unconstrainedDimensions.contains(expressionToSaturate)) {
+                                        return PolyhedronSaturationResult.SATURATED
+                                }
+                                val j = getIndex(expressionToSaturate)
+                                objective.set(j, 1)
+                        }
+                        LinearConstraint: {
+                                for (pair : expressionToSaturate.coefficients.entrySet) {
+                                        val dimension = pair.key
+                                        // We also have to check for unconstrained dimensions here to avoid crashing.
+                                        if (unconstrainedDimensions.contains(dimension)) {
+                                                expressionToSaturate.lowerBound = null
+                                                expressionToSaturate.upperBound = null
+                                                return PolyhedronSaturationResult.SATURATED
+                                        }
+                                        val j = getIndex(dimension)
+                                        objective.set(j, pair.value)
+                                }
+                        }
+                        default:
+                                throw new IllegalArgumentException("Unknown expression: " + expressionToSaturate)
+                }
+                val minimizationResult = CbcSolver.solve(columnLowerBounds, columnUpperBounds, rowStarts, columnIndices,
+                        entries, rowLowerBounds, rowUpperBounds, objective, lpRelaxation, timeoutSeconds, silent)
+                switch (minimizationResult) {
+                        CbcResult.SolutionBounded: {
+                                val doubleValue = minimizationResult.value
+                                val roundedValue = Math.ceil(doubleValue - EPSILON)
+                                val intValue = roundedValue as int
+                                val oldBound = expressionToSaturate.lowerBound
+                                if (oldBound === null || intValue >= oldBound) {
+                                        expressionToSaturate.lowerBound = intValue
+                                        setBound(expressionToSaturate, constraints, roundedValue, columnLowerBounds, rowLowerBounds)
+                                } else {
+                                        throw new IllegalStateException("Unexpected decrease of lower bound by " + (oldBound - doubleValue))
+                                }
+                        }
+                        case CbcResult.SOLUTION_UNBOUNDED: {
+                                if (expressionToSaturate.lowerBound !== null) {
+                                        throw new IllegalStateException("Finite lower bound became infinite")
+                                }
+                                setBound(expressionToSaturate, constraints, Double.NEGATIVE_INFINITY, columnLowerBounds, rowLowerBounds)
+                        }
+                        case CbcResult.UNSAT:
+                                return PolyhedronSaturationResult.EMPTY
+                        case CbcResult.ABANDONED,
+                        case CbcResult.TIMEOUT:
+                                return PolyhedronSaturationResult.UNKNOWN
+                        default:
+                                throw new RuntimeException("Unknown CbcResult: " + minimizationResult)
+                }
+                for (var int j = 0; j < numDimensions; j++) {
+                        val objectiveCoefficient = objective.get(j)
+                        objective.set(j, -objectiveCoefficient)
+                }
+                val maximizationResult = CbcSolver.solve(columnLowerBounds, columnUpperBounds, rowStarts, columnIndices,
+                        entries, rowLowerBounds, rowUpperBounds, objective, lpRelaxation, timeoutSeconds, silent)
+                switch (maximizationResult) {
+                        CbcResult.SolutionBounded: {
+                                val doubleValue = -maximizationResult.value
+                                val roundedValue = Math.floor(doubleValue + EPSILON)
+                                val intValue = roundedValue as int
+                                val oldBound = expressionToSaturate.upperBound
+                                if (oldBound === null || intValue <= oldBound) {
+                                        expressionToSaturate.upperBound = intValue
+                                        setBound(expressionToSaturate, constraints, roundedValue, columnUpperBounds, rowUpperBounds)
+                                } else {
+                                        throw new IllegalStateException("Unexpected increase of upper bound by " + (doubleValue - oldBound))
+                                }
+                        }
+                        case CbcResult.SOLUTION_UNBOUNDED: {
+                                if (expressionToSaturate.lowerBound !== null) {
+                                        throw new IllegalStateException("Finite upper bound became infinite")
+                                }
+                                expressionToSaturate.upperBound = null
+                                setBound(expressionToSaturate, constraints, Double.POSITIVE_INFINITY, columnUpperBounds, rowUpperBounds)
+                        }
+                        case CbcResult.UNSAT:
+                                throw new RuntimeException("Minimization was SAT, but maximization is UNSAT")
+                        case CbcResult.ABANDONED,
+                        case CbcResult.TIMEOUT:
+                                return PolyhedronSaturationResult.UNKNOWN
+                        default:
+                                throw new RuntimeException("Unknown CbcResult: " + maximizationResult)
+                }
+                return PolyhedronSaturationResult.SATURATED
+        }
+
+        private def toDouble(Integer nullableInt, double defaultValue) {
+                if (nullableInt === null) {
+                        defaultValue
+                } else {
+                        nullableInt.doubleValue
+                }
+        }
+
+        private def int getIndex(Dimension dimension) {
+                val index = dimensionsToIndicesMap.get(dimension)
+                if (index === null) {
+                        throw new IllegalArgumentException("Unknown dimension: " + dimension)
+                }
+                index
+        }
+
+        private def void setBound(LinearBoundedExpression expression, List<LinearConstraint> constraints, double bound,
+                double[] columnBounds, double[] rowBounds) {
+                switch (expression) {
+                        Dimension: {
+                                val j = getIndex(expression)
+                                columnBounds.set(j, bound)
+                        }
+                        LinearConstraint: {
+                                val i = constraints.indexOf(expression)
+                                if (i >= 0) {
+                                        rowBounds.set(i, bound)
+                                }
+                        }
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/LinearTypeConstraintHint.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/LinearTypeConstraintHint.xtend
new file mode 100644
index 00000000..8c21ca1d
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/LinearTypeConstraintHint.xtend
@@ -0,0 +1,30 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PatternGenerator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+
+interface LinearTypeExpressionBuilderFactory {
+        def ViatraQueryMatcher<? extends IPatternMatch> createMatcher(String queryName)
+        
+        def LinearTypeExpressionBuilder createBuilder()
+}
+
+interface LinearTypeExpressionBuilder {
+        def LinearTypeExpressionBuilder add(int scale, Type type)
+
+        def LinearBoundedExpression build()
+}
+
+@FunctionalInterface
+interface RelationConstraintUpdater {
+        def void update(PartialInterpretation p)
+}
+
+interface LinearTypeConstraintHint {
+        def CharSequence getAdditionalPatterns(PatternGenerator patternGenerator)
+        
+        def RelationConstraintUpdater createConstraintUpdater(LinearTypeExpressionBuilderFactory builderFactory)
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/MultiplicityGoalConstraintCalculator.xtend
index 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..51dba244
--- /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,578 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import com.google.common.cache.Cache
+import com.google.common.cache.CacheBuilder
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.ImmutableMap
+import com.google.common.collect.ImmutableSet
+import com.google.common.collect.Maps
+import com.google.common.collect.Sets
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.UnifinishedMultiplicityQueries
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope
+import java.util.ArrayDeque
+import java.util.ArrayList
+import java.util.Collection
+import java.util.HashMap
+import java.util.HashSet
+import java.util.List
+import java.util.Map
+import java.util.Set
+import javax.naming.OperationNotSupportedException
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.viatra.query.runtime.emf.EMFScope
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+class PolyhedronScopePropagator extends TypeHierarchyScopePropagator {
+        static val CACHE_SIZE = 10000
+        
+        val boolean updateHeuristic
+        val Map<Scope, LinearBoundedExpression> scopeBounds
+        val LinearBoundedExpression topLevelBounds
+        val Polyhedron polyhedron
+        val PolyhedronSaturationOperator operator
+        val Set<Relation> relevantRelations
+        val Cache<PolyhedronSignature, PolyhedronSignature> cache = CacheBuilder.newBuilder.maximumSize(CACHE_SIZE).build
+        List<RelationConstraintUpdater> updaters = emptyList
+
+        new(PartialInterpretation p, ModelGenerationStatistics statistics, Set<? extends Type> possibleNewDynamicTypes,
+                Map<RelationMultiplicityConstraint, UnifinishedMultiplicityQueries> unfinishedMultiplicityQueries,
+                IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hasElementInContainmentQuery,
+                Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allPatternsByName,
+                Collection<LinearTypeConstraintHint> hints, PolyhedronSolver solver, boolean propagateRelations,
+                boolean updateHeuristic) {
+                super(p, statistics)
+                this.updateHeuristic = updateHeuristic
+                val builder = new PolyhedronBuilder(p)
+                builder.buildPolyhedron(possibleNewDynamicTypes)
+                scopeBounds = builder.scopeBounds
+                topLevelBounds = builder.topLevelBounds
+                polyhedron = builder.polyhedron
+                operator = solver.createSaturationOperator(polyhedron)
+                propagateAllScopeConstraints()
+                if (propagateRelations) {
+                        val maximumNumberOfNewNodes = topLevelBounds.upperBound
+                        if (maximumNumberOfNewNodes === null) {
+                                throw new IllegalStateException("Could not determine maximum number of new nodes, it may be unbounded")
+                        }
+                        if (maximumNumberOfNewNodes <= 0) {
+                                throw new IllegalStateException("Maximum number of new nodes is not positive")
+                        }
+                        builder.buildMultiplicityConstraints(unfinishedMultiplicityQueries, hasElementInContainmentQuery,
+                                allPatternsByName, hints, maximumNumberOfNewNodes)
+                        relevantRelations = builder.relevantRelations
+                        updaters = builder.updaters
+                } else {
+                        relevantRelations = emptySet
+                }
+        }
+
+        override void doPropagateAllScopeConstraints() {
+                super.doPropagateAllScopeConstraints()
+                resetBounds()
+                populatePolyhedronFromScope()
+//              println(polyhedron)
+                val signature = polyhedron.createSignature
+                val cachedSignature = cache.getIfPresent(signature)
+                switch (cachedSignature) {
+                        case null: {
+                                statistics.incrementScopePropagationSolverCount
+                                val result = operator.saturate()
+                                if (result == PolyhedronSaturationResult.EMPTY) {
+                                        cache.put(signature, PolyhedronSignature.EMPTY)
+                                        setScopesInvalid()
+                                } else {
+                                        val resultSignature = polyhedron.createSignature
+                                        cache.put(signature, resultSignature)
+                                        populateScopesFromPolyhedron()
+                                }
+                        }
+                        case PolyhedronSignature.EMPTY:
+                                setScopesInvalid()
+                        PolyhedronSignature.Bounds: {
+                                polyhedron.applySignature(signature)
+                                populateScopesFromPolyhedron()
+                        }
+                        default:
+                                throw new IllegalStateException("Unknown polyhedron signature: " + signature)
+                }
+//              println(polyhedron)
+                if (updateHeuristic) {
+                        copyScopeBoundsToHeuristic()
+                }
+        }
+
+        override propagateAdditionToRelation(Relation r) {
+                super.propagateAdditionToRelation(r)
+                if (relevantRelations.contains(r)) {
+                        propagateAllScopeConstraints()
+                }
+        }
+
+        def resetBounds() {
+                for (dimension : polyhedron.dimensions) {
+                        dimension.lowerBound = 0
+                        dimension.upperBound = null
+                }
+                for (constraint : polyhedron.constraints) {
+                        constraint.lowerBound = null
+                        constraint.upperBound = null
+                }
+        }
+
+        private def populatePolyhedronFromScope() {
+                topLevelBounds.tightenLowerBound(partialInterpretation.minNewElements)
+                if (partialInterpretation.maxNewElements >= 0) {
+                        topLevelBounds.tightenUpperBound(partialInterpretation.maxNewElements)
+                }
+                for (pair : scopeBounds.entrySet) {
+                        val scope = pair.key
+                        val bounds = pair.value
+                        bounds.tightenLowerBound(scope.minNewElements)
+                        if (scope.maxNewElements >= 0) {
+                                bounds.tightenUpperBound(scope.maxNewElements)
+                        }
+                }
+                for (updater : updaters) {
+                        updater.update(partialInterpretation)
+                }
+        }
+
+        private def populateScopesFromPolyhedron() {
+                checkBounds(topLevelBounds)
+                if (partialInterpretation.minNewElements > topLevelBounds.lowerBound) {
+                        throw new IllegalArgumentException('''Lower bound of «topLevelBounds» smaller than top-level scope: «partialInterpretation.minNewElements»''')
+                } else if (partialInterpretation.minNewElements != topLevelBounds.lowerBound) {
+                        partialInterpretation.minNewElements = topLevelBounds.lowerBound
+                }
+                val topLevelUpperBound = topLevelBounds.upperBound ?: -1
+                if (partialInterpretation.maxNewElements >= 0 && topLevelUpperBound >= 0 &&
+                        partialInterpretation.maxNewElements < topLevelUpperBound) {
+                        throw new IllegalArgumentException('''Upper bound of «topLevelBounds» larger than top-level scope: «partialInterpretation.maxNewElements»''')
+                } else if (partialInterpretation.maxNewElements != topLevelUpperBound) {
+                        partialInterpretation.maxNewElements = topLevelUpperBound
+                }
+                for (pair : scopeBounds.entrySet) {
+                        val scope = pair.key
+                        val bounds = pair.value
+                        checkBounds(bounds)
+                        if (scope.minNewElements > bounds.lowerBound) {
+                                throw new IllegalArgumentException('''Lower bound of «bounds» smaller than «scope.targetTypeInterpretation» scope: «scope.minNewElements»''')
+                        } else if (scope.minNewElements != bounds.lowerBound) {
+                                scope.minNewElements = bounds.lowerBound
+                        }
+                        val upperBound = bounds.upperBound ?: -1
+                        if (scope.maxNewElements >= 0 && upperBound >= 0 && scope.maxNewElements < upperBound) {
+                                throw new IllegalArgumentException('''Upper bound of «bounds» larger than «scope.targetTypeInterpretation» scope: «scope.maxNewElements»''')
+                        } else if (scope.maxNewElements != upperBound) {
+                                scope.maxNewElements = upperBound
+                        }
+                }
+        }
+
+        private def checkBounds(LinearBoundedExpression bounds) {
+                if (bounds.lowerBound === null) {
+                        throw new IllegalArgumentException("Infinite lower bound: " + bounds)
+                } else if (bounds.lowerBound < 0) {
+                        throw new IllegalArgumentException("Negative lower bound: " + bounds)
+                }
+                if (bounds.upperBound !== null && bounds.upperBound < 0) {
+                        throw new IllegalArgumentException("Negative upper bound: " + bounds)
+                }
+        }
+
+        private 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 implements LinearTypeExpressionBuilderFactory {
+                static val INFINITY_SCALE = 10
+
+                val PartialInterpretation p
+
+                Map<Type, Dimension> instanceCounts
+                Map<Type, Map<Dimension, Integer>> subtypeDimensions
+                Map<Map<Dimension, Integer>, LinearBoundedExpression> expressionsCache
+                Map<Type, LinearBoundedExpression> typeBounds
+                int infinity
+                ViatraQueryEngine queryEngine
+                Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allPatternsByName
+                ImmutableList.Builder<RelationConstraintUpdater> updatersBuilder
+
+                Map<Scope, LinearBoundedExpression> scopeBounds
+                LinearBoundedExpression topLevelBounds
+                Polyhedron polyhedron
+                Set<Relation> relevantRelations
+                List<RelationConstraintUpdater> updaters
+
+                def buildPolyhedron(Set<? extends Type> possibleNewDynamicTypes) {
+                        instanceCounts = possibleNewDynamicTypes.toInvertedMap[new Dimension(name, 0, null)]
+                        val types = p.problem.types
+                        expressionsCache = Maps.newHashMapWithExpectedSize(types.size)
+                        subtypeDimensions = types.toInvertedMap[findSubtypeDimensions.toInvertedMap[1]]
+                        typeBounds = ImmutableMap.copyOf(subtypeDimensions.mapValues[toExpression])
+                        scopeBounds = buildScopeBounds
+                        topLevelBounds = instanceCounts.values.toInvertedMap[1].toExpression
+                        val dimensions = ImmutableList.copyOf(instanceCounts.values)
+                        val expressionsToSaturate = ImmutableList.copyOf(scopeBounds.values)
+                        polyhedron = new Polyhedron(dimensions, new ArrayList, expressionsToSaturate)
+                        addCachedConstraintsToPolyhedron()
+                }
+
+                def buildMultiplicityConstraints(
+                        Map<RelationMultiplicityConstraint, UnifinishedMultiplicityQueries> constraints,
+                        IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hasElementInContainmentQuery,
+                        Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allPatternsByName,
+                        Collection<LinearTypeConstraintHint> hints, int maximumNuberOfNewNodes) {
+                        infinity = maximumNuberOfNewNodes * INFINITY_SCALE
+                        queryEngine = ViatraQueryEngine.on(new EMFScope(p))
+                        this.allPatternsByName = allPatternsByName
+                        updatersBuilder = ImmutableList.builder
+                        val containmentConstraints = constraints.entrySet.filter[key.containment].groupBy[key.targetType]
+                        for (pair : containmentConstraints.entrySet) {
+                                buildContainmentConstraints(pair.key, pair.value)
+                        }
+                        buildConstainmentRootConstraints(containmentConstraints.keySet, hasElementInContainmentQuery)
+                        for (pair : constraints.entrySet) {
+                                val constraint = pair.key
+                                if (!constraint.containment) {
+                                        buildNonContainmentConstraints(constraint, pair.value)
+                                }
+                        }
+                        buildRelevantRelations(constraints.keySet)
+                        for (hint : hints) {
+                                updatersBuilder.add(hint.createConstraintUpdater(this))
+                        }
+                        updaters = updatersBuilder.build
+                        addCachedConstraintsToPolyhedron()
+                }
+
+                private def buildRelevantRelations(Set<RelationMultiplicityConstraint> constraints) {
+                        val builder = ImmutableSet.builder
+                        for (constraint : constraints) {
+                                builder.add(constraint.relation)
+                                if (constraint.inverseRelation !== null) {
+                                        builder.add(constraint.inverseRelation)
+                                }
+                        }
+                        relevantRelations = builder.build
+                }
+
+                private def addCachedConstraintsToPolyhedron() {
+                        val constraints = new HashSet
+                        constraints.addAll(expressionsCache.values.filter(LinearConstraint))
+                        constraints.removeAll(polyhedron.constraints)
+                        polyhedron.constraints.addAll(constraints)
+                }
+
+                private def buildContainmentConstraints(Type containedType,
+                        List<Map.Entry<RelationMultiplicityConstraint, UnifinishedMultiplicityQueries>> constraints) {
+                        val typeCoefficients = subtypeDimensions.get(containedType)
+                        val orphansLowerBoundCoefficients = new HashMap(typeCoefficients)
+                        val orphansUpperBoundCoefficients = new HashMap(typeCoefficients)
+                        val unfinishedMultiplicitiesMatchersBuilder = ImmutableList.builder
+                        val remainingContentsQueriesBuilder = ImmutableList.builder
+                        for (pair : constraints) {
+                                val constraint = pair.key
+                                val containerCoefficients = subtypeDimensions.get(constraint.sourceType)
+                                if (constraint.isUpperBoundFinite) {
+                                        orphansLowerBoundCoefficients.addCoefficients(-constraint.upperBound, containerCoefficients)
+                                } else {
+                                        orphansLowerBoundCoefficients.addCoefficients(-infinity, containerCoefficients)
+                                }
+                                orphansUpperBoundCoefficients.addCoefficients(-constraint.lowerBound, containerCoefficients)
+                                val queries = pair.value
+                                if (constraint.constrainsUnfinished) {
+                                        if (queries.unfinishedMultiplicityQuery === null) {
+                                                throw new IllegalArgumentException(
+                                                        "Containment constraints need unfinished multiplicity queries")
+                                        }
+                                        unfinishedMultiplicitiesMatchersBuilder.add(
+                                                queries.unfinishedMultiplicityQuery.getMatcher(queryEngine))
+                                }
+                                if (queries.remainingContentsQuery === null) {
+                                        throw new IllegalArgumentException("Containment constraints need remaining contents queries")
+                                }
+                                remainingContentsQueriesBuilder.add(queries.remainingContentsQuery.getMatcher(queryEngine))
+                        }
+                        val orphanLowerBound = orphansLowerBoundCoefficients.toExpression
+                        val orphanUpperBound = orphansUpperBoundCoefficients.toExpression
+                        val updater = new ContainmentConstraintUpdater(containedType.name, orphanLowerBound, orphanUpperBound,
+                                unfinishedMultiplicitiesMatchersBuilder.build, remainingContentsQueriesBuilder.build)
+                        updatersBuilder.add(updater)
+                }
+
+                private def buildConstainmentRootConstraints(Set<Type> containedTypes,
+                        IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hasElementInContainmentQuery) {
+                        val matcher = hasElementInContainmentQuery.getMatcher(queryEngine)
+                        val rootDimensions = Sets.newHashSet(instanceCounts.values)
+                        for (type : containedTypes) {
+                                val containedDimensions = subtypeDimensions.get(type).keySet
+                                rootDimensions.removeAll(containedDimensions)
+                        }
+                        for (dimension : rootDimensions) {
+                                updatersBuilder.add(new ContainmentRootConstraintUpdater(dimension, matcher))
+                        }
+                }
+
+                private def buildNonContainmentConstraints(RelationMultiplicityConstraint constraint,
+                        UnifinishedMultiplicityQueries queries) {
+                        if (constraint.constrainsRemainingInverse) {
+                                if (queries.unfinishedMultiplicityQuery === null) {
+                                        throw new IllegalArgumentException("Reference constraints need unfinished multiplicity queries")
+                                }
+                                val unfinishedMultiplicityMatcher = queries.unfinishedMultiplicityQuery.getMatcher(queryEngine)
+                                if (queries.remainingInverseMultiplicityQuery === null) {
+                                        throw new IllegalArgumentException(
+                                                "Reference constraints need remaining inverse multiplicity queries")
+                                }
+                                val remainingInverseMultiplicityMatcher = queries.remainingInverseMultiplicityQuery.getMatcher(
+                                        queryEngine)
+                                val availableMultiplicityCoefficients = new HashMap
+                                availableMultiplicityCoefficients.addCoefficients(constraint.inverseUpperBound,
+                                        subtypeDimensions.get(constraint.targetType))
+                                availableMultiplicityCoefficients.addCoefficients(-constraint.lowerBound,
+                                        subtypeDimensions.get(constraint.targetType))
+                                val availableMultiplicity = availableMultiplicityCoefficients.toExpression
+                                updatersBuilder.add(
+                                        new UnfinishedMultiplicityConstraintUpdater(constraint.relation.name, availableMultiplicity,
+                                                unfinishedMultiplicityMatcher, remainingInverseMultiplicityMatcher))
+                        }
+                        if (constraint.constrainsUnrepairable) {
+                                if (queries.unrepairableMultiplicityQuery === null) {
+                                        throw new IllegalArgumentException("Reference constraints need unrepairable multiplicity queries")
+                                }
+                                val unrepairableMultiplicityMatcher = queries.unrepairableMultiplicityQuery.getMatcher(queryEngine)
+                                val targetTypeCardinality = typeBounds.get(constraint.targetType)
+                                updatersBuilder.add(
+                                        new UnrepairableMultiplicityConstraintUpdater(constraint.relation.name, targetTypeCardinality,
+                                                unrepairableMultiplicityMatcher))
+                        }
+                }
+
+                private static def addCoefficients(Map<Dimension, Integer> accumulator, int scale, Map<Dimension, Integer> a) {
+                        for (pair : a.entrySet) {
+                                val dimension = pair.key
+                                val currentValue = accumulator.get(pair.key) ?: 0
+                                val newValue = currentValue + scale * pair.value
+                                if (newValue == 0) {
+                                        accumulator.remove(dimension)
+                                } else {
+                                        accumulator.put(dimension, newValue)
+                                }
+                        }
+                }
+
+                private def findSubtypeDimensions(Type type) {
+                        val subtypes = new HashSet
+                        val dimensions = new HashSet
+                        val stack = new ArrayDeque
+                        stack.addLast(type)
+                        while (!stack.empty) {
+                                val subtype = stack.removeLast
+                                if (subtypes.add(subtype)) {
+                                        val dimension = instanceCounts.get(subtype)
+                                        if (dimension !== null) {
+                                                dimensions.add(dimension)
+                                        }
+                                        stack.addAll(subtype.subtypes)
+                                }
+                        }
+                        dimensions
+                }
+
+                private def toExpression(Map<Dimension, Integer> coefficients) {
+                        expressionsCache.computeIfAbsent(coefficients) [ c |
+                                if (c.size == 1 && c.entrySet.head.value == 1) {
+                                        c.entrySet.head.key
+                                } else {
+                                        new LinearConstraint(c, null, null)
+                                }
+                        ]
+                }
+
+                private def buildScopeBounds() {
+                        val scopeBoundsBuilder = ImmutableMap.builder
+                        for (scope : p.scopes) {
+                                switch (targetTypeInterpretation : scope.targetTypeInterpretation) {
+                                        PartialPrimitiveInterpretation:
+                                                throw new OperationNotSupportedException("Primitive type scopes are not yet implemented")
+                                        PartialComplexTypeInterpretation: {
+                                                val complexType = targetTypeInterpretation.interpretationOf
+                                                val typeBound = typeBounds.get(complexType)
+                                                if (typeBound === null) {
+                                                        if (scope.minNewElements > 0) {
+                                                                throw new IllegalArgumentException("Found scope for " + complexType.name +
+                                                                        ", but the type cannot be instantiated")
+                                                        }
+                                                } else {
+                                                        scopeBoundsBuilder.put(scope, typeBound)
+                                                }
+                                        }
+                                        default:
+                                                throw new IllegalArgumentException("Unknown PartialTypeInterpretation: " +
+                                                        targetTypeInterpretation)
+                                }
+                        }
+                        scopeBoundsBuilder.build
+                }
+
+                override createMatcher(String queryName) {
+                        val querySpecification = allPatternsByName.get(queryName)
+                        if (querySpecification === null) {
+                                throw new IllegalArgumentException("Unknown pattern: " + queryName)
+                        }
+                        querySpecification.getMatcher(queryEngine)
+                }
+
+                override createBuilder() {
+                        new PolyhedronBuilderLinearTypeExpressionBuilder(this)
+                }
+        }
+
+        @FinalFieldsConstructor
+        private static class PolyhedronBuilderLinearTypeExpressionBuilder implements LinearTypeExpressionBuilder {
+                val PolyhedronBuilder polyhedronBuilder
+                val Map<Dimension, Integer> coefficients = new HashMap
+
+                override add(int scale, Type type) {
+                        val typeCoefficients = polyhedronBuilder.subtypeDimensions.get(type)
+                        if (typeCoefficients === null) {
+                                throw new IllegalArgumentException("Unknown type: " + type)
+                        }
+                        PolyhedronBuilder.addCoefficients(coefficients, scale, typeCoefficients)
+                        this
+                }
+
+                override build() {
+                        polyhedronBuilder.toExpression(coefficients)
+                }
+        }
+
+        @FinalFieldsConstructor
+        private static class ContainmentConstraintUpdater implements RelationConstraintUpdater {
+                val String name
+                val LinearBoundedExpression orphansLowerBound
+                val LinearBoundedExpression orphansUpperBound
+                val List<ViatraQueryMatcher<? extends IPatternMatch>> unfinishedMultiplicitiesMatchers
+                val List<ViatraQueryMatcher<? extends IPatternMatch>> remainingContentsQueries
+
+                override update(PartialInterpretation p) {
+                        tightenLowerBound(p)
+                        tightenUpperBound(p)
+                }
+
+                private def tightenLowerBound(PartialInterpretation p) {
+                        var int sum = 0
+                        for (matcher : remainingContentsQueries) {
+                                val value = matcher.getCalculatedMultiplicity(p)
+                                if (value === null) {
+                                        throw new IllegalArgumentException("Remaining contents count is missing for " + name)
+                                }
+                                if (value == -1) {
+                                        // Infinite upper bound, no need to tighten.
+                                        return
+                                }
+                                sum += value
+                        }
+                        orphansLowerBound.tightenUpperBound(sum)
+                }
+
+                private def tightenUpperBound(PartialInterpretation p) {
+                        var int sum = 0
+                        for (matcher : unfinishedMultiplicitiesMatchers) {
+                                val value = matcher.getCalculatedMultiplicity(p)
+                                if (value === null) {
+                                        throw new IllegalArgumentException("Unfinished multiplicity is missing for " + name)
+                                }
+                                sum += value
+                        }
+                        orphansUpperBound.tightenLowerBound(sum)
+                }
+        }
+
+        @FinalFieldsConstructor
+        private static class ContainmentRootConstraintUpdater implements RelationConstraintUpdater {
+                val LinearBoundedExpression typeCardinality
+                val ViatraQueryMatcher<? extends IPatternMatch> hasElementInContainmentMatcher
+
+                override update(PartialInterpretation p) {
+                        if (hasElementInContainmentMatcher.hasMatch(p)) {
+                                typeCardinality.tightenUpperBound(0)
+                        } else {
+                                typeCardinality.tightenUpperBound(1)
+                        }
+                }
+
+                private static def <T extends IPatternMatch> hasMatch(ViatraQueryMatcher<T> matcher, PartialInterpretation p) {
+                        val match = matcher.newMatch(p.problem, p)
+                        matcher.countMatches(match) != 0
+                }
+        }
+
+        @FinalFieldsConstructor
+        private static class UnfinishedMultiplicityConstraintUpdater implements RelationConstraintUpdater {
+                val String name
+                val LinearBoundedExpression availableMultiplicityExpression
+                val ViatraQueryMatcher<? extends IPatternMatch> unfinishedMultiplicityMatcher
+                val ViatraQueryMatcher<? extends IPatternMatch> remainingInverseMultiplicityMatcher
+
+                override update(PartialInterpretation p) {
+                        val unfinishedMultiplicity = unfinishedMultiplicityMatcher.getCalculatedMultiplicity(p)
+                        if (unfinishedMultiplicity === null) {
+                                throw new IllegalArgumentException("Unfinished multiplicity is missing for " + name)
+                        }
+                        val remainingInverseMultiplicity = remainingInverseMultiplicityMatcher.getCalculatedMultiplicity(p)
+                        if (remainingInverseMultiplicity === null) {
+                                throw new IllegalArgumentException("Remaining inverse multiplicity is missing for " + name)
+                        }
+                        val int requiredMultiplicity = unfinishedMultiplicity - remainingInverseMultiplicity
+                        availableMultiplicityExpression.tightenLowerBound(requiredMultiplicity)
+                }
+        }
+
+        @FinalFieldsConstructor
+        private static class UnrepairableMultiplicityConstraintUpdater implements RelationConstraintUpdater {
+                val String name
+                val LinearBoundedExpression targetCardinalityExpression
+                val ViatraQueryMatcher<? extends IPatternMatch> unrepairableMultiplicityMatcher
+
+                override update(PartialInterpretation p) {
+                        val value = unrepairableMultiplicityMatcher.getCalculatedMultiplicity(p)
+                        if (value === null) {
+                                throw new IllegalArgumentException("Unrepairable multiplicity is missing for " + name)
+                        }
+                        targetCardinalityExpression.tightenLowerBound(value)
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronSolver.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronSolver.xtend
new file mode 100644
index 00000000..4e046190
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronSolver.xtend
@@ -0,0 +1,179 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import java.util.List
+import java.util.Map
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.Data
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+interface PolyhedronSolver {
+        def PolyhedronSaturationOperator createSaturationOperator(Polyhedron polyhedron)
+}
+
+enum PolyhedronSaturationResult {
+        SATURATED,
+        EMPTY,
+        UNKNOWN
+}
+
+interface PolyhedronSaturationOperator extends AutoCloseable {
+        def Polyhedron getPolyhedron()
+
+        def PolyhedronSaturationResult saturate()
+}
+
+@FinalFieldsConstructor
+@Accessors
+class Polyhedron {
+        /**
+         * The list of dimensions (variables) for this polyhedron.
+         * 
+         * This list must not be modified after the polyhedron was created.
+         * However, lower and upper bounds of the dimensions may be changed.
+         * 
+         * Names of dimensions in this list are assumed to be unique.
+         */
+        val List<Dimension> dimensions
+
+        /**
+         * The list of constraints defining this polyhedron.
+         * 
+         * The list and its elements may be freely modified.
+         */
+        val List<LinearConstraint> constraints
+
+        /**
+         * The list of constraints that should be saturated (tightened)
+         * when a {@link PolyhedronSaturationOperator} is invoked.
+         * 
+         * This list may be freely modified.
+         * 
+         * Place all dimensions and constraints here to saturate all the bounds.
+         */
+        val List<LinearBoundedExpression> expressionsToSaturate
+
+        override toString() '''
+                Dimensions:
+                        «FOR dimension : dimensions»
+                                «dimension»
+                        «ENDFOR»
+                Constraints:
+                        «FOR constraint : constraints»
+                                «constraint»
+                        «ENDFOR»
+        '''
+
+        def createSignature() {
+                val size = dimensions.size + constraints.size
+                val lowerBounds = newArrayOfSize(size)
+                val upperBounds = newArrayOfSize(size)
+                var int i = 0
+                for (dimension : dimensions) {
+                        lowerBounds.set(i, dimension.lowerBound)
+                        upperBounds.set(i, dimension.upperBound)
+                        i++
+                }
+                for (constraint : constraints) {
+                        lowerBounds.set(i, constraint.lowerBound)
+                        upperBounds.set(i, constraint.upperBound)
+                        i++
+                }
+                new PolyhedronSignature.Bounds(lowerBounds, upperBounds)
+        }
+
+        def applySignature(PolyhedronSignature.Bounds signature) {
+                val lowerBounds = signature.lowerBounds
+                val upperBounds = signature.upperBounds
+                var int i = 0
+                for (dimension : dimensions) {
+                        dimension.lowerBound = lowerBounds.get(i)
+                        dimension.upperBound = upperBounds.get(i)
+                        i++
+                }
+                for (constraint : constraints) {
+                        constraint.lowerBound = lowerBounds.get(i)
+                        constraint.upperBound = upperBounds.get(i)
+                        i++
+                }
+        }
+}
+
+abstract class PolyhedronSignature {
+        public static val EMPTY = new PolyhedronSignature {
+                override toString() {
+                        "PolyhedronSignature.EMPTY"
+                }
+        }
+
+        private new() {
+        }
+
+        @Data
+        static class Bounds extends PolyhedronSignature {
+                val Integer[] lowerBounds
+                val Integer[] upperBounds
+        }
+}
+
+@Accessors
+abstract class LinearBoundedExpression {
+        var Integer lowerBound
+        var Integer upperBound
+
+        def void tightenLowerBound(Integer tighterBound) {
+                if (lowerBound === null || (tighterBound !== null && lowerBound < tighterBound)) {
+                        lowerBound = tighterBound
+                }
+        }
+
+        def void tightenUpperBound(Integer tighterBound) {
+                if (upperBound === null || (tighterBound !== null && upperBound > tighterBound)) {
+                        upperBound = tighterBound
+                }
+        }
+
+        def void assertEqualsTo(int bound) {
+                tightenLowerBound(bound)
+                tightenUpperBound(bound)
+        }
+}
+
+@Accessors
+class Dimension extends LinearBoundedExpression {
+        val String name
+
+        @FinalFieldsConstructor
+        new() {
+        }
+
+        new(String name, Integer lowerBound, Integer upperBound) {
+                this(name)
+                this.lowerBound = lowerBound
+                this.upperBound = upperBound
+        }
+
+        override toString() {
+                '''«IF lowerBound !== null»«lowerBound» <= «ENDIF»«name»«IF upperBound !== null» <= «upperBound»«ENDIF»'''
+        }
+
+}
+
+@Accessors
+class LinearConstraint extends LinearBoundedExpression {
+        val Map<Dimension, Integer> coefficients
+
+        @FinalFieldsConstructor
+        new() {
+        }
+
+        new(Map<Dimension, Integer> coefficients, Integer lowerBound, Integer upperBound) {
+                this(coefficients)
+                this.lowerBound = lowerBound
+                this.upperBound = upperBound
+        }
+
+        override toString() {
+                '''«IF lowerBound !== null»«lowerBound» <= «ENDIF»«FOR pair : coefficients.entrySet SEPARATOR " + "»«IF pair.value != 1»«pair.value» * «ENDIF»«pair.key.name»«ENDFOR»«IF upperBound !== null» <= «upperBound»«ENDIF»'''
+        }
+
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/RelationConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/RelationConstraintCalculator.xtend
new file mode 100644
index 00000000..c92260ea
--- /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,137 @@
+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 && false
+        }
+
+        def constrainsRemainingInverse() {
+                lowerBound >= 1 && !containment && inverseUpperBoundFinite
+        }
+
+        def constrainsRemainingContents() {
+                containment
+        }
+
+        def isActive() {
+                constrainsUnfinished || constrainsUnrepairable || constrainsRemainingInverse || constrainsRemainingContents
+        }
+
+        def getSourceType() {
+                getParamType(0)
+        }
+
+        def getTargetType() {
+                getParamType(1)
+        }
+
+        private def getParamType(int i) {
+                val parameters = relation.parameters
+                if (i < parameters.size) {
+                        val firstParam = parameters.get(i)
+                        if (firstParam instanceof ComplexTypeReference) {
+                                return firstParam.referred
+                        }
+                }
+                throw new IllegalArgumentException("Constraint with unknown source type")
+        }
+}
+
+class RelationConstraintCalculator {
+        def calculateRelationConstraints(LogicProblem problem) {
+                val containmentRelations = switch (problem.containmentHierarchies.size) {
+                        case 0:
+                                <Relation>emptySet
+                        case 1:
+                                ImmutableSet.copyOf(problem.containmentHierarchies.head.containmentRelations)
+                        default:
+                                throw new IllegalArgumentException("Only a single containment hierarchy is supported")
+                }
+                val inverseRelations = new HashMap<Relation, Relation>
+                val lowerMultiplicities = new HashMap<Relation, Integer>
+                val upperMultiplicities = new HashMap<Relation, Integer>
+                for (relation : problem.relations) {
+                        lowerMultiplicities.put(relation, 0)
+                        upperMultiplicities.put(relation, -1)
+                }
+                for (annotation : problem.annotations) {
+                        switch (annotation) {
+                                InverseRelationAssertion: {
+                                        inverseRelations.put(annotation.inverseA, annotation.inverseB)
+                                        inverseRelations.put(annotation.inverseB, annotation.inverseA)
+                                }
+                                LowerMultiplicityAssertion:
+                                        lowerMultiplicities.put(annotation.relation, annotation.lower)
+                                UpperMultiplicityAssertion:
+                                        upperMultiplicities.put(annotation.relation, annotation.upper)
+                        }
+                }
+                val multiplicityConstraintsBuilder = ImmutableList.builder()
+                for (relation : problem.relations) {
+                        val containment = containmentRelations.contains(relation)
+                        val lowerMultiplicity = lowerMultiplicities.get(relation)
+                        val upperMultiplicity = upperMultiplicities.get(relation)
+                        var container = false
+                        var inverseUpperMultiplicity = -1
+                        val inverseRelation = inverseRelations.get(relation)
+                        if (inverseRelation !== null) {
+                                inverseUpperMultiplicity = upperMultiplicities.get(inverseRelation)
+                                container = containmentRelations.contains(inverseRelation)
+                        }
+                        if (containment) {
+                                inverseUpperMultiplicity = 1
+                        }
+                        val constraint = new RelationMultiplicityConstraint(relation, inverseRelation, containment, container,
+                                lowerMultiplicity, upperMultiplicity, inverseUpperMultiplicity)
+                        if (constraint.isActive) {
+                                if (relation.parameters.size != 2) {
+                                        throw new IllegalArgumentException('''Relation «relation.name» has multiplicity or containment constraints, but it is not binary''')
+                                }
+                                multiplicityConstraintsBuilder.add(constraint)
+                        }
+                }
+                new RelationConstraints(multiplicityConstraintsBuilder.build)
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagator.xtend
new file mode 100644
index 00000000..2376fb38
--- /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,126 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality

+

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

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

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

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

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

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

+import java.util.HashMap

+import java.util.HashSet

+import java.util.Map

+import java.util.Set

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

+

+class ScopePropagator {

+        @Accessors(PROTECTED_GETTER) val PartialInterpretation partialInterpretation

+        @Accessors(PROTECTED_GETTER) val ModelGenerationStatistics statistics

+        val Map<PartialTypeInterpratation, Scope> type2Scope

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

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

+

+        new(PartialInterpretation p, ModelGenerationStatistics statistics) {

+                partialInterpretation = p

+                this.statistics = statistics

+                type2Scope = new HashMap

+                for (scope : p.scopes) {

+                        type2Scope.put(scope.targetTypeInterpretation, scope)

+                }

+

+                superScopes = new HashMap

+                subScopes = new HashMap

+                for (scope : p.scopes) {

+                        superScopes.put(scope, new HashSet)

+                        subScopes.put(scope, new HashSet)

+                }

+

+                for (scope : p.scopes) {

+                        val target = scope.targetTypeInterpretation

+                        if (target instanceof PartialComplexTypeInterpretation) {

+                                val supertypeInterpretations = target.supertypeInterpretation

+                                for (supertypeInterpretation : supertypeInterpretations) {

+                                        val supertypeScope = type2Scope.get(supertypeInterpretation)

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

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

+                                }

+                        }

+                }

+                var boolean changed

+                do {

+                        changed = false

+                        for (scope : p.scopes) {

+                                val subScopeSet = subScopes.get(scope)

+                                val superScopeSet = superScopes.get(scope)

+                                for (subScope : subScopeSet) {

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

+                                }

+                                for (superScope : superScopeSet) {

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

+                                }

+                        }

+                } while (changed)

+                

+                copyScopeBoundsToHeuristic()

+        }

+

+        def propagateAllScopeConstraints() {

+                statistics.incrementScopePropagationCount()

+                doPropagateAllScopeConstraints()

+        }

+        

+        protected def copyScopeBoundsToHeuristic() {

+                partialInterpretation.minNewElementsHeuristic = partialInterpretation.minNewElements

+                for (scope : partialInterpretation.scopes) {

+                        scope.minNewElementsHeuristic = scope.minNewElements

+                }

+        }

+

+        protected def void doPropagateAllScopeConstraints() {

+                // Nothing to propagate.

+        }

+

+        def propagateAdditionToType(PartialTypeInterpratation t) {

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

+                val targetScope = type2Scope.get(t)

+                if (targetScope !== null) {

+                        targetScope.removeOne

+                        val sups = superScopes.get(targetScope)

+                        sups.forEach[removeOne]

+                }

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

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

+                }

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

+                        this.partialInterpretation.minNewElementsHeuristic = this.partialInterpretation.minNewElementsHeuristic - 1

+                }

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

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

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

+                        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

+                }

+                if (scope.minNewElementsHeuristic > 0) {

+                        scope.minNewElementsHeuristic = scope.minNewElementsHeuristic - 1

+                }

+        }

+}

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

 

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

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

-import org.eclipse.emf.ecore.EClass

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

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

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

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

 

 class GenericTypeIndexer extends TypeIndexer {

-        val PatternGenerator base;

-        

         new(PatternGenerator base) {

-                this.base = base

+                super(base)

         }

+

         override requiresTypeAnalysis() { false }

-        

-        public override getRequiredQueries() '''

-        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..5c35fb54 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
@@ -1,7 +1,6 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

 

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

-import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion

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

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

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

@@ -17,7 +16,11 @@ import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.Transform
 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality

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

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

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

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

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

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

+import java.util.Collection

 import java.util.HashMap

 import java.util.Map

 import org.eclipse.emf.ecore.EAttribute

@@ -28,20 +31,23 @@ import org.eclipse.xtend.lib.annotations.Accessors
 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

 

 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 +55,103 @@ class PatternGenerator {
                         this.typeRefinementGenerator = null

                         throw new IllegalArgumentException('''Unknown type indexing technique : «typeInferenceMethod.name»''')

                 }

+                this.unfinishedIndexer = new UnfinishedIndexer(this, scopePropagatorStrategy.requiresUpperBoundIndexing)

         }

-        

-        public def requiresTypeAnalysis() {

+

+        def requiresTypeAnalysis() {

                 typeIndexer.requiresTypeAnalysis || typeRefinementGenerator.requiresTypeAnalysis

         }

-        

-        public dispatch def referRelation(

-                RelationDeclaration referred,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality,

-                Map<String,PQuery> fqn2PQuery)

-        {

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

+

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

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

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

         }

-        public dispatch def referRelation(

-                RelationDefinition referred,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality,

-                Map<String,PQuery> fqn2PQuery)

-        {

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

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

+

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

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

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

+                        fqn2PQuery)

+                return this.relationDefinitionIndexer.referPattern(pattern, #[sourceVariable, targetVariable], modality, true,

+                        false)

         }

-        

-        def public referRelationByName(EReference reference,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality)

-        {

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

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

+

+        def referRelationByName(EReference reference, String sourceVariable, String targetVariable, Modality modality) {

+                '''find «modality.name.toLowerCase»InRelation«canonizeName('''«reference.name» reference «reference.EContainingClass.name»''')»(problem,interpretation,«sourceVariable»,«targetVariable»);'''

         }

-        

-        def public CharSequence referAttributeByName(EAttribute attribute,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality)

-        {

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

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

+

+        def CharSequence referAttributeByName(EAttribute attribute, String sourceVariable, String targetVariable,

+                Modality modality) {

+                '''find «modality.name.toLowerCase»InRelation«canonizeName('''«attribute.name» attribute «attribute.EContainingClass.name»''')»(problem,interpretation,«sourceVariable»,«targetVariable»);'''

         }

-        

-        public def canonizeName(String name) {

+

+        def canonizeName(String name) {

                 name.split(' ').join('_')

         }

-        

-        public def lowerMultiplicities(LogicProblem problem) {

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

-        }

-        public def wfQueries(LogicProblem problem) {

-                problem.assertions.map[it.annotations]

-                        .flatten

-                        .filter(TransformedViatraWellformednessConstraint)

-                        .map[it.query]

+

+        def wfQueries(LogicProblem problem) {

+                problem.assertions.map[it.annotations].flatten.filter(TransformedViatraWellformednessConstraint).map[it.query]

         }

-        public def getContainments(LogicProblem p) {

+

+        def getContainments(LogicProblem p) {

                 return p.containmentHierarchies.head.containmentRelations

         }

-        public def getInverseRelations(LogicProblem p) {

+

+        def getInverseRelations(LogicProblem p) {

                 val inverseRelations = new HashMap

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

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

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

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

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

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

                 ]

                 return inverseRelations

         }

-        public def isRepresentative(Relation relation, Relation inverse) {

-                if(inverse == null) {

+

+        def isRepresentative(Relation relation, Relation inverse) {

+                if (relation === null) {

+                        return false

+                } else if (inverse === null) {

                         return true

                 } else {

-                        relation.name.compareTo(inverse.name)<1

+                        relation.name.compareTo(inverse.name) < 1

                 }

         }

-        

-        public def isDerived(Relation relation) {

+

+        def isDerived(Relation relation) {

                 relation.annotations.exists[it instanceof DefinedByDerivedFeature]

         }

-        public def getDerivedDefinition(RelationDeclaration relation) {

+

+        def getDerivedDefinition(RelationDeclaration relation) {

                 relation.annotations.filter(DefinedByDerivedFeature).head.query

         }

-        

+

         private def allTypeReferences(LogicProblem problem) {

                 problem.eAllContents.filter(TypeReference).toIterable

         }

+

         protected def hasBoolean(LogicProblem problem) {

                 problem.allTypeReferences.exists[it instanceof BoolTypeReference]

         }

+

         protected def hasInteger(LogicProblem problem) {

                 problem.allTypeReferences.exists[it instanceof IntTypeReference]

         }

+

         protected def hasReal(LogicProblem problem) {

                 problem.allTypeReferences.exists[it instanceof RealTypeReference]

         }

+

         protected def hasString(LogicProblem problem) {

                 problem.allTypeReferences.exists[it instanceof StringTypeReference]

         }

-        

-        public def transformBaseProperties(

+

+        def transformBaseProperties(

                 LogicProblem problem,

                 PartialInterpretation emptySolution,

-                Map<String,PQuery> fqn2PQuery,

-                TypeAnalysisResult typeAnalysisResult

+                Map<String, PQuery> fqn2PQuery,

+                TypeAnalysisResult typeAnalysisResult,

+                RelationConstraints constraints,

+                Collection<LinearTypeConstraintHint> hints

         ) {

-                

+

                 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 +185,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 +218,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 +276,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 +299,13 @@ class PatternGenerator {
                         // 4.3 Relation refinement

                         //////////

                         «relationRefinementGenerator.generateRefineReference(problem)»

-                        '''

+                        

+                        //////////

+                        // 5 Hints

+                        //////////

+                        «FOR hint : hints»

+                                «hint.getAdditionalPatterns(this)»

+                        «ENDFOR»

+                '''

         }

 }

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..f5c85524 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,117 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
 import org.eclipse.xtend.lib.annotations.Data

 

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

-import java.util.Collection

-import java.util.Set

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

 

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

+                Collection<LinearTypeConstraintHint> hints, 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, hints)

+                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..0ae28b66 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
@@ -5,6 +5,7 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
 import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransfomedViatraQuery

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

 import java.util.Map

+import org.eclipse.emf.common.util.Enumerator

 import org.eclipse.emf.ecore.EAttribute

 import org.eclipse.emf.ecore.EEnumLiteral

 import org.eclipse.emf.ecore.EReference

@@ -17,6 +18,7 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality
 import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter

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

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

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

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

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

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

@@ -24,7 +26,6 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeCo
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery

 

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

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

 

 class RelationDefinitionIndexer {

         val PatternGenerator base;

@@ -33,7 +34,7 @@ class RelationDefinitionIndexer {
                 this.base = base

         }

         

-        public def generateRelationDefinitions(

+        def generateRelationDefinitions(

                 LogicProblem problem,

                 Iterable<RelationDefinition> relations,

                 Map<String,PQuery> fqn2PQuery) {

@@ -71,7 +72,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) {

@@ -109,7 +110,7 @@ class RelationDefinitionIndexer {
                 else return Modality::MUST

         } 

         

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

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

                 «IF !positive»neg «ENDIF»find «IF transitive»twoParam_«ENDIF»«modality.name.toLowerCase»InRelation_pattern_«p.fullyQualifiedName.replace('.','_')»«IF transitive»+«ENDIF»(«IF !transitive»problem,interpretation,«ENDIF»«variables.join(',')»);

         '''

         

@@ -227,7 +228,11 @@ class RelationDefinitionIndexer {
                 var String additionalDefinition;

                 if(target instanceof EEnumLiteral) {

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

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

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

+                } else if(target instanceof Enumerator) {

+                        // XXX We should get the corresponding EEnum name instead of the java class name.

+                        targetString = '''const_«target.name»_«target.class.simpleName»'''

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

                 } else if(target instanceof Integer) {

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

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

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend
index f9e9baea..d915d47e 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend
@@ -9,77 +9,71 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
 

 class RelationRefinementGenerator {

         PatternGenerator base;

+

         public new(PatternGenerator base) {

                 this.base = base

         }

-        

-        def CharSequence generateRefineReference(LogicProblem p) {

-                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..a8a07756 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend
@@ -1,85 +1,204 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

 

-import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion

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

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

-import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransformedViatraWellformednessConstraint

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

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

+import java.util.LinkedHashMap

+import java.util.List

 import java.util.Map

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

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

 

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

-import java.util.LinkedHashMap

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

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

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

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

+                                                «ELSE»

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

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

+                                                        «ELSE»

+                                                                find interpretation(problem,interpretation);

+                                                                find mustExist(problem,interpretation,source);

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

+                                                                find mustExist(problem,interpretation,target);

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

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

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

+                                                        «ENDIF»

+                                                «ENDIF»

+                                        }

+                                «ENDIF»

+                                

+                                «IF constraint.constrainsUnrepairable»

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

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

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

+                                                check(numberOfRepairMatches < missingMultiplicity);

+                                                unrepairableMultiplicity == eval(missingMultiplicity-numberOfRepairMatches);

+                                        }

+                                        

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

+                                                find interpretation(problem,interpretation);

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

+                                        } or {

+                                                find interpretation(problem,interpretation);

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

+                                                unrepairableMultiplicity == 0;

+                                        }

+                                «ENDIF»

+                                

+                                «IF constraint.constrainsRemainingInverse»

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

+                                                find interpretation(problem,interpretation);

+                                                find mustExist(problem,interpretation,object);

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

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

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

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

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

+                                        }

+                                        

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

+                                                find interpretation(problem,interpretation);

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

+                                        }

+                                «ENDIF»

+                                

+                                «IF constraint.constrainsRemainingContents»

+                                        «IF constraint.upperBoundFinite»

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

+                                                        find interpretation(problem,interpretation);

+                                                        find mustExist(problem,interpretation,object);

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

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

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

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

+                                                }

+                                                

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

+                                                        find interpretation(problem,interpretation);

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

+                                                }

+                                        «ELSE»

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

+                                                        find interpretation(problem,interpretation);

+                                                        find mustExist(problem,interpretation,object);

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

+                                                }

+                                                

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

+                                                        find interpretation(problem,interpretation);

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

+                                                        remainingMultiplicity == -1;

+                                                } or {

+                                                        find interpretation(problem,interpretation);

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

+                                                        remainingMultiplicity == 0;

+                                                }

+                                        «ENDIF»

+                                «ENDIF»

+                        «ENDIF»

                 «ENDFOR»

-                '''

-        }

-        def String unfinishedMultiplicityName(LowerMultiplicityAssertion lowerMultiplicityAssertion) 

-                '''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..7891ebd8 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

@@ -67,7 +67,8 @@ class RefinementRuleProvider {
                 if(containmentRelation != null) {

                         if(inverseRelation!= null) {

                                 ruleBuilder.action[match |

-                                        //println(name)

+                                        statistics.incrementTransformationCount

+//                                      println(name)

                                         val startTime = System.nanoTime

                                         //val problem = match.get(0) as LogicProblem

                                         val interpretation = match.get(1) as PartialInterpretation

@@ -98,14 +99,17 @@ 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 |

-                                        //println(name)

+                                        statistics.incrementTransformationCount

+//                                      println(name)

                                         val startTime = System.nanoTime

                                         //val problem = match.get(0) as LogicProblem

                                         val interpretation = match.get(1) as PartialInterpretation

@@ -132,14 +136,19 @@ 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 {

                         ruleBuilder.action[match |

+                                statistics.incrementTransformationCount

+//                              println(name)

+                                

                                 val startTime = System.nanoTime

                                 //val problem = match.get(0) as LogicProblem

                                 val interpretation = match.get(1) as PartialInterpretation

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

@@ -192,8 +203,9 @@ class RefinementRuleProvider {
                         .precondition(lhs)

                 if (inverseRelation == null) {

                         ruleBuilder.action [ match |

+                                statistics.incrementTransformationCount

                             val startTime = System.nanoTime

-                                //println(name)

+//                              println(name)

                                 // val problem = match.get(0) as LogicProblem

                                 // val interpretation = match.get(1) as PartialInterpretation

                                 val relationInterpretation = match.get(2) as PartialRelationInterpretation

@@ -201,12 +213,19 @@ 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 |

+                                statistics.incrementTransformationCount

                             val startTime = System.nanoTime

-                                //println(name)

+//                              println(name)

                                 // val problem = match.get(0) as LogicProblem

                                 // val interpretation = match.get(1) as PartialInterpretation

                                 val relationInterpretation = match.get(2) as PartialRelationInterpretation

@@ -217,7 +236,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)

                         ]

                 }