merge with current master, comment numerical solver related logging

46 files changed, 6377 insertions, 1433 deletions

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF
index 23e3ad13..ec1557e8 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/META-INF/MANIFEST.MF
@@ -4,8 +4,12 @@ Bundle-Name: Logic2viatra
 Bundle-SymbolicName: hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatraquery;singleton:=true
 Bundle-Version: 1.0.0.qualifier
 Export-Package: hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.interval.aggregators,
  hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns,
- hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.queries,
+ hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules
 Require-Bundle: hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0",
  hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage;bundle-version="1.0.0",
  hu.bme.mit.inf.dslreasoner.ecore2logic;bundle-version="1.0.0",
@@ -14,13 +18,16 @@ Require-Bundle: hu.bme.mit.inf.dslreasoner.logic.model;bundle-version="1.0.0",
  org.eclipse.xtext.xbase.lib,
  org.eclipse.xtend.lib,
  org.eclipse.xtend.lib.macro,
- org.eclipse.viatra.query.runtime;bundle-version="1.5.0",
- org.eclipse.viatra.query.runtime.base.itc;bundle-version="1.5.0",
- org.eclipse.viatra.query.patternlanguage.emf;bundle-version="1.5.0",
+ org.eclipse.viatra.query.runtime;bundle-version="2.0.0",
+ org.eclipse.viatra.query.runtime.base.itc;bundle-version="2.0.0",
+ org.eclipse.viatra.query.patternlanguage.emf;bundle-version="2.0.0",
  com.google.inject;bundle-version="3.0.0",
  org.eclipse.xtext;bundle-version="2.10.0",
- org.eclipse.viatra.transformation.runtime.emf;bundle-version="1.5.0",
- org.eclipse.xtext.xbase;bundle-version="2.10.0"
+ org.eclipse.viatra.transformation.runtime.emf;bundle-version="2.0.0",
+ org.eclipse.xtext.xbase;bundle-version="2.10.0",
+ com.microsoft.z3;bundle-version="4.8.5",
+ hu.bme.mit.inf.dslreasoner.ilp.cbc;bundle-version="1.0.0",
+ org.eclipse.viatra.query.runtime.rete;bundle-version="2.0.0"
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Import-Package: org.apache.log4j
 Automatic-Module-Name: hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatraquery
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/build.properties b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/build.properties
index 585df5ce..9ffc994a 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/build.properties
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/build.properties
@@ -4,6 +4,5 @@ bin.includes = META-INF/,\
 source.. = src/,\

            patterns/,\

            vql-gen/,\

-           xtend-gen/,\

-           src-gen/

+           xtend-gen/

 output.. = bin/

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/Modality.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/Modality.java
index d2132cea..f3a6ec32 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/Modality.java
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/Modality.java
@@ -2,21 +2,46 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra;
 

 public enum Modality {

         MUST, MAY, CURRENT;

+

         public boolean isMust() {

                 return this == MUST;

         }

+

         public boolean isMay() {

                 return this == MAY;

         }

+

         public boolean isCurrent() {

                 return this == CURRENT;

         }

+

         public boolean isMustOrCurrent() {

                 return isMust() || isCurrent();

         }

+

         public Modality getDual() {

-                if(this.isCurrent()) return CURRENT;

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

-                else return MUST;

+                switch (this) {

+                case CURRENT:

+                        return CURRENT;

+                case MUST:

+                        return MAY;

+                case MAY:

+                        return MUST;

+                default:

+                        throw new UnsupportedOperationException("Unknown Modality: " + this);

+                }

+        }

+

+        public Modality toBase() {

+                if (this.isCurrent()) {

+                        return MUST;

+                } else {

+                        return this;

+                }

+        }

+

+        @Override

+        public String toString() {

+                return super.toString().toLowerCase();

         }

 }

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

-

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

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

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

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

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

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

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

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

-import java.util.Collection

-import java.util.List

-import java.util.Set

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

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

-import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher

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

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

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

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

-import java.util.Map

-

-class ModelGenerationStatistics {

-        public var long transformationExecutionTime = 0

-        public var long metricCalculationTime = 0

-        

-        synchronized def addExecutionTime(long amount) {

-                transformationExecutionTime+=amount

-        }

-        

-        synchronized def addMetricCalculationTime(long amount) {

-                metricCalculationTime+=amount

-        }

-        

-        public var long PreliminaryTypeAnalisisTime = 0

-}

-@Data class ModelGenerationMethod {

-         ModelGenerationStatistics statistics

-         

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

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

-         

-         List<MultiplicityGoalConstraintCalculator> unfinishedMultiplicities

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

-         

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

-         

-         Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> mustUnitPropagationPreconditions

-         Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> currentUnitPropagationPreconditions

-         

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

-}

-enum TypeInferenceMethod {

-        Generic, PreliminaryAnalysis

-}

-

-class ModelGenerationMethodProvider {

-        private val PatternProvider patternProvider = new PatternProvider

-        private val RefinementRuleProvider refinementRuleProvider = new RefinementRuleProvider

-        private val GoalConstraintProvider goalConstraintProvider = new GoalConstraintProvider

-        

-        public def ModelGenerationMethod createModelGenerationMethod(

-                LogicProblem logicProblem,

-                PartialInterpretation emptySolution,

-                ReasonerWorkspace workspace,

-                boolean nameNewElements,

-                TypeInferenceMethod typeInferenceMethod,

-                ScopePropagator scopePropagator,

-                DocumentationLevel debugLevel,

-                boolean objectCreationCosts

-        ) {

-                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(logicProblem, emptySolution, queries,scopePropagator,nameNewElements,statistics)

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

-                

-                val unfinishedMultiplicities = goalConstraintProvider.getUnfinishedMultiplicityQueries(logicProblem,queries,objectCreationCosts)

-                val unfinishedWF = queries.getUnfinishedWFQueries.values

-                

-                val invalidWF = queries.getInvalidWFQueries.values

-                

-                val mustUnitPropagationPreconditions = queries.getMustUnitPropagationPreconditionPatterns

-                val currentUnitPropagationPreconditions = queries.getCurrentUnitPropagationPreconditionPatterns

-                

-                return new ModelGenerationMethod(

-                        statistics,

-                        objectRefinementRules.values,

-                        relationRefinementRules.values,

-                        unfinishedMultiplicities,

-                        unfinishedWF,

-                        invalidWF,

-                        mustUnitPropagationPreconditions,

-                        currentUnitPropagationPreconditions,

-                        queries.allQueries

-                )

-        }

-}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationStatistics.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationStatistics.xtend
new file mode 100644
index 00000000..ab4fa039
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationStatistics.xtend
@@ -0,0 +1,52 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra
+
+class ModelGenerationStatistics {
+        public var long transformationExecutionTime = 0
+        public var long metricCalculationTime = 0
+        
+        
+        synchronized def addMetricCalculationTime(long amount) {
+                metricCalculationTime+=amount
+        }
+        synchronized def addExecutionTime(long amount) {
+                transformationExecutionTime += amount
+        }
+
+        public var long scopePropagationTime = 0
+
+        synchronized def addScopePropagationTime(long amount) {
+                scopePropagationTime += amount
+        }
+
+        public var long mustRelationPropagationTime = 0
+
+        synchronized def addMustRelationPropagationTime(long amount) {
+                mustRelationPropagationTime += amount
+        }
+
+        public var long preliminaryTypeAnalisisTime = 0
+
+        public var int decisionsTried = 0
+
+        synchronized def incrementDecisionCount() {
+                decisionsTried++
+        }
+
+        public var int transformationInvocations
+
+        synchronized def incrementTransformationCount() {
+                transformationInvocations++
+        }
+
+        public var int scopePropagatorInvocations
+
+        synchronized def incrementScopePropagationCount() {
+                scopePropagatorInvocations++
+        }
+
+        public var int scopePropagatorSolverInvocations
+
+        synchronized def incrementScopePropagationSolverCount() {
+                scopePropagatorSolverInvocations++
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend
deleted file mode 100644
index 05ce4f6e..00000000
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend
+++ /dev/null
@@ -1,66 +0,0 @@
-package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra

-

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

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

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

-import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher

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

-

-class MultiplicityGoalConstraintCalculator {

-        val String targetRelationName;

-        val IQuerySpecification<?> querySpecification;

-        var ViatraQueryMatcher<?> matcher;

-        val int minValue

-        val boolean containment

-        val int cost

-                

-        public new(String targetRelationName, IQuerySpecification<?> querySpecification, int minValue, boolean containment, int cost) {

-                this.targetRelationName = targetRelationName

-                this.querySpecification = querySpecification

-                this.matcher = null

-                this.minValue = minValue

-                this.containment = containment

-                this.cost = cost

-        }

-        

-        public new(MultiplicityGoalConstraintCalculator other) {

-                this.targetRelationName = other.targetRelationName

-                this.querySpecification = other.querySpecification

-                this.matcher = null

-                this.minValue = other.minValue

-                this.containment = other.containment

-                this.cost = other.cost

-        }

-        

-        def public getName() {

-                targetRelationName

-        }

-        

-        def isContainment() {

-                return containment

-        }

-        

-        def public init(Notifier notifier) {

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

-                matcher = querySpecification.getMatcher(engine)

-        }

-        

-        def public calculateValue() {

-                var res = 0

-                val allMatches = this.matcher.allMatches

-                for(match : allMatches) {

-                        

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

-                        if(existingMultiplicity < this.minValue) {

-                                val missingMultiplicity = this.minValue-existingMultiplicity

-                                res += missingMultiplicity

-                        }

-//                      if(missingMultiplicity!=0) {

-//                              println(targetRelationName+ " missing multiplicity: "+missingMultiplicity)

-//                      }

-                }

-//              if(res>0)

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

-                return res*cost

-        }

-}
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ScopePropagator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ScopePropagator.xtend
deleted file mode 100644
index 8012776f..00000000
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ScopePropagator.xtend
+++ /dev/null
@@ -1,166 +0,0 @@
-package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra

-

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

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

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

-import java.util.HashMap

-import java.util.Map

-import java.util.Set

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

-import java.util.HashSet

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

-

-class ScopePropagator {

-        PartialInterpretation partialInterpretation

-        Map<PartialTypeInterpratation,Scope> type2Scope

-        

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

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

-        

-        public new(PartialInterpretation p) {

-                partialInterpretation = p

-                type2Scope = new HashMap

-                for(scope : p.scopes) {

-                        type2Scope.put(scope.targetTypeInterpretation,scope)

-                }

-                

-                superScopes = new HashMap

-                subScopes = new HashMap

-                for(scope : p.scopes) {

-                        superScopes.put(scope,new HashSet)

-                        subScopes.put(scope,new HashSet)

-                }

-                

-                for(scope : p.scopes) {

-                        val target = scope.targetTypeInterpretation

-                        if(target instanceof PartialComplexTypeInterpretation) {

-                                val supertypeInterpretations = target.supertypeInterpretation

-                                for(supertypeInterpretation : supertypeInterpretations) {

-                                        val supertypeScope = type2Scope.get(supertypeInterpretation)

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

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

-                                }

-                        }

-                }

-        }

-        

-        def public propagateAllScopeConstraints() {

-                var boolean hadChanged

-                do{

-                        hadChanged = false

-                        for(superScopeEntry : superScopes.entrySet) {

-                                val sub = superScopeEntry.key

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

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

-                                for(sup: superScopeEntry.value) {

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

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

-                                }

-                        }

-                } while(hadChanged)

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

-        }

-        

-        def public propagateAdditionToType(PartialTypeInterpratation t) {

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

-                if(!isPrimitive) {

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

-                        val targetScope = type2Scope.get(t)

-                        if(targetScope!==null) {

-                                targetScope.removeOne

-                                val sups = superScopes.get(targetScope)

-                                sups.forEach[removeOne]

-                        }

-                        

-                        

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

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

-                        }

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

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

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

-                                this.partialInterpretation.maxNewElements = 0

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

-                        }

-                        

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

-        //              for(sup: sups) {

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

-        //              }

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

-        //                      propagateUpperLimitDown(scope,partialInterpretation)

-        //              }

-        

-                        propagateAllScopeConstraints

-                        

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

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

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

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

-                }

-        }

-        

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

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

-//                      println('''

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

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

-//                      ''')

-                        superScope.minNewElements = subScope.minNewElements

-                        return true

-                } else {

-                        return false

-                }

-        }

-        

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

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

-//                      println('''

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

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

-//                      ''')

-                        subScope.maxNewElements = superScope.maxNewElements

-                        return true

-                } else {

-                        return false

-                }

-        }

-        

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

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

-//                      println('''

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

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

-//                      ''')

-                        p.minNewElements = subScope.minNewElements

-                        return true

-                } else {

-                        return false

-                }

-        }

-        

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

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

-//                      println('''

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

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

-//                      ''')

-                        subScope.maxNewElements = p.maxNewElements

-                        return true

-                } else {

-                        return false

-                }

-        }

-        private def removeOne(Scope scope) {

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

-                        scope.maxNewElements=0

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

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

-                        scope.maxNewElements= scope.maxNewElements-1

-                }

-                if(scope.minNewElements>0) {

-                        scope.minNewElements= scope.minNewElements-1

-                }

-        }

-}

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

+

+import com.google.common.collect.ImmutableMap

+import com.google.common.collect.ImmutableSet

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+import java.util.Collection

+import java.util.List

+import java.util.Map

+import java.util.Set

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

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

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

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

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

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

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

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

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

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

+

+enum TypeInferenceMethod {

+        Generic,

+        PreliminaryAnalysis

+}
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/AbstractPolyhedronSaturationOperator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/AbstractPolyhedronSaturationOperator.xtend
new file mode 100644
index 00000000..94f97e94
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/AbstractPolyhedronSaturationOperator.xtend
@@ -0,0 +1,53 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import com.google.common.collect.ImmutableList
+import org.eclipse.xtend.lib.annotations.Accessors
+
+abstract class AbstractPolyhedronSaturationOperator implements PolyhedronSaturationOperator {
+        @Accessors val Polyhedron polyhedron
+
+        new(Polyhedron polyhedron) {
+                if (polyhedron.dimensions.empty) {
+                        throw new IllegalArgumentException("Polyhedron must have at least one dimension.")
+                }
+                this.polyhedron = polyhedron
+        }
+
+        override saturate() {
+                if (polyhedron.expressionsToSaturate.empty) {
+                        return PolyhedronSaturationResult.SATURATED
+                }
+                for (constraint : polyhedron.constraints) {
+                        if (constraint.zero) {
+                                if (constraint.lowerBound !== null && constraint.lowerBound > 0) {
+                                        return PolyhedronSaturationResult.EMPTY
+                                }
+                                if (constraint.upperBound !== null && constraint.upperBound < 0) {
+                                        return PolyhedronSaturationResult.EMPTY
+                                }
+                        } else {
+                                if (constraint.lowerBound !== null && constraint.upperBound !== null &&
+                                        constraint.upperBound < constraint.lowerBound) {
+                                        return PolyhedronSaturationResult.EMPTY
+                                }
+                        }
+                }
+                doSaturate()
+        }
+
+        protected def PolyhedronSaturationResult doSaturate()
+
+        protected def getNonTrivialConstraints() {
+                ImmutableList.copyOf(polyhedron.constraints.filter [ constraint |
+                        (constraint.lowerBound !== null || constraint.upperBound !== null) && !constraint.zero
+                ])
+        }
+
+        private static def isZero(LinearConstraint constraint) {
+                constraint.coefficients.values.forall[it == 0]
+        }
+
+        override close() throws Exception {
+                // Nothing to close by default.
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/CbcPolyhedronSolver.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/CbcPolyhedronSolver.xtend
new file mode 100644
index 00000000..708f93dc
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/CbcPolyhedronSolver.xtend
@@ -0,0 +1,241 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.ImmutableMap
+import hu.bme.mit.inf.dslreasoner.ilp.cbc.CbcResult
+import hu.bme.mit.inf.dslreasoner.ilp.cbc.CbcSolver
+import java.util.HashSet
+import java.util.List
+import java.util.Map
+import java.util.Set
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+@FinalFieldsConstructor
+class CbcPolyhedronSolver implements PolyhedronSolver {
+        val boolean lpRelaxation
+        val double timeoutSeconds
+        val boolean silent
+
+        new() {
+                this(false, -1, true)
+        }
+
+        override createSaturationOperator(Polyhedron polyhedron) {
+                new CbcSaturationOperator(polyhedron, lpRelaxation, timeoutSeconds, silent)
+        }
+}
+
+class CbcSaturationOperator extends AbstractPolyhedronSaturationOperator {
+        static val EPSILON = 1e-6
+
+        val boolean lpRelaxation
+        val double timeoutSeconds
+        val boolean silent
+        val double[] columnLowerBounds
+        val double[] columnUpperBounds
+        val double[] objective
+        val Map<Dimension, Integer> dimensionsToIndicesMap
+
+        new(Polyhedron polyhedron, boolean lpRelaxation, double timeoutSeconds, boolean silent) {
+                super(polyhedron)
+                this.lpRelaxation = lpRelaxation
+                this.timeoutSeconds = timeoutSeconds
+                this.silent = silent
+                val numDimensions = polyhedron.dimensions.size
+                columnLowerBounds = newDoubleArrayOfSize(numDimensions)
+                columnUpperBounds = newDoubleArrayOfSize(numDimensions)
+                objective = newDoubleArrayOfSize(numDimensions)
+                dimensionsToIndicesMap = ImmutableMap.copyOf(polyhedron.dimensions.indexed.toMap([value], [key]))
+        }
+
+        override doSaturate() {
+                val numDimensions = polyhedron.dimensions.size
+                for (var int j = 0; j < numDimensions; j++) {
+                        val dimension = polyhedron.dimensions.get(j)
+                        columnLowerBounds.set(j, dimension.lowerBound.toDouble(Double.NEGATIVE_INFINITY))
+                        columnUpperBounds.set(j, dimension.upperBound.toDouble(Double.POSITIVE_INFINITY))
+                }
+                val constraints = nonTrivialConstraints
+                val numConstraints = constraints.size
+                val rowStarts = newIntArrayOfSize(numConstraints + 1)
+                val rowLowerBounds = newDoubleArrayOfSize(numConstraints)
+                val rowUpperBounds = newDoubleArrayOfSize(numConstraints)
+                val numEntries = constraints.map[coefficients.size].reduce[a, b|a + b] ?: 0
+                rowStarts.set(numConstraints, numEntries)
+                val columnIndices = newIntArrayOfSize(numEntries)
+                val entries = newDoubleArrayOfSize(numEntries)
+                val unconstrainedDimensions = new HashSet
+                for (dimension : polyhedron.dimensions) {
+                        if (dimension.lowerBound === null && dimension.upperBound === null) {
+                                unconstrainedDimensions += dimension
+                        }
+                }
+                var int index = 0
+                for (var int i = 0; i < numConstraints; i++) {
+                        rowStarts.set(i, index)
+                        val constraint = constraints.get(i)
+                        rowLowerBounds.set(i, constraint.lowerBound.toDouble(Double.NEGATIVE_INFINITY))
+                        rowUpperBounds.set(i, constraint.upperBound.toDouble(Double.POSITIVE_INFINITY))
+                        if (!dimensionsToIndicesMap.keySet.containsAll(constraint.coefficients.keySet)) {
+                                throw new IllegalArgumentException("Constrains has unknown dimensions")
+                        }
+                        for (var int j = 0; j < numDimensions; j++) {
+                                val dimension = polyhedron.dimensions.get(j)
+                                val coefficient = constraint.coefficients.get(dimension)
+                                if (coefficient !== null && coefficient != 0) {
+                                        unconstrainedDimensions -= dimension
+                                        columnIndices.set(index, j)
+                                        entries.set(index, coefficient)
+                                        index++
+                                }
+                        }
+                }
+                if (index != numEntries) {
+                        throw new AssertionError("Last entry does not equal the number of entries in the constraint matrix")
+                }
+                for (expressionToSaturate : polyhedron.expressionsToSaturate) {
+                        val result = saturate(expressionToSaturate, rowStarts, columnIndices, entries, rowLowerBounds,
+                                rowUpperBounds, unconstrainedDimensions, constraints)
+                        if (result != PolyhedronSaturationResult.SATURATED) {
+                                return result
+                        }
+                }
+                PolyhedronSaturationResult.SATURATED
+        }
+
+        protected def saturate(LinearBoundedExpression expressionToSaturate, int[] rowStarts, int[] columnIndices,
+                double[] entries, double[] rowLowerBounds, double[] rowUpperBounds, Set<Dimension> unconstrainedDimensions,
+                ImmutableList<LinearConstraint> constraints) {
+                val numDimensions = objective.size
+                for (var int j = 0; j < numDimensions; j++) {
+                        objective.set(j, 0)
+                }
+                switch (expressionToSaturate) {
+                        Dimension: {
+                                // CBC will return nonsensical results or call free() with invalid arguments if
+                                // it is passed a fully unconstrained (-Inf lower and +Int upper bound, no inequalities) variable
+                                // in the objective function.
+                                if (unconstrainedDimensions.contains(expressionToSaturate)) {
+                                        return PolyhedronSaturationResult.SATURATED
+                                }
+                                val j = getIndex(expressionToSaturate)
+                                objective.set(j, 1)
+                        }
+                        LinearConstraint: {
+                                for (pair : expressionToSaturate.coefficients.entrySet) {
+                                        val dimension = pair.key
+                                        // We also have to check for unconstrained dimensions here to avoid crashing.
+                                        if (unconstrainedDimensions.contains(dimension)) {
+                                                expressionToSaturate.lowerBound = null
+                                                expressionToSaturate.upperBound = null
+                                                return PolyhedronSaturationResult.SATURATED
+                                        }
+                                        val j = getIndex(dimension)
+                                        objective.set(j, pair.value)
+                                }
+                        }
+                        default:
+                                throw new IllegalArgumentException("Unknown expression: " + expressionToSaturate)
+                }
+                val minimizationResult = CbcSolver.solve(columnLowerBounds, columnUpperBounds, rowStarts, columnIndices,
+                        entries, rowLowerBounds, rowUpperBounds, objective, lpRelaxation, timeoutSeconds, silent)
+                switch (minimizationResult) {
+                        CbcResult.SolutionBounded: {
+                                val doubleValue = minimizationResult.value
+                                val roundedValue = Math.ceil(doubleValue - EPSILON)
+                                val intValue = roundedValue as int
+                                val oldBound = expressionToSaturate.lowerBound
+                                if (oldBound === null || intValue >= oldBound) {
+                                        expressionToSaturate.lowerBound = intValue
+                                        setBound(expressionToSaturate, constraints, roundedValue, columnLowerBounds, rowLowerBounds)
+                                } else {
+                                        throw new IllegalStateException("Unexpected decrease of lower bound by " + (oldBound - doubleValue))
+                                }
+                        }
+                        case CbcResult.SOLUTION_UNBOUNDED: {
+                                if (expressionToSaturate.lowerBound !== null) {
+                                        throw new IllegalStateException("Finite lower bound became infinite")
+                                }
+                                setBound(expressionToSaturate, constraints, Double.NEGATIVE_INFINITY, columnLowerBounds, rowLowerBounds)
+                        }
+                        case CbcResult.UNSAT:
+                                return PolyhedronSaturationResult.EMPTY
+                        case CbcResult.ABANDONED,
+                        case CbcResult.TIMEOUT:
+                                return PolyhedronSaturationResult.UNKNOWN
+                        default:
+                                throw new RuntimeException("Unknown CbcResult: " + minimizationResult)
+                }
+                for (var int j = 0; j < numDimensions; j++) {
+                        val objectiveCoefficient = objective.get(j)
+                        objective.set(j, -objectiveCoefficient)
+                }
+                val maximizationResult = CbcSolver.solve(columnLowerBounds, columnUpperBounds, rowStarts, columnIndices,
+                        entries, rowLowerBounds, rowUpperBounds, objective, lpRelaxation, timeoutSeconds, silent)
+                switch (maximizationResult) {
+                        CbcResult.SolutionBounded: {
+                                val doubleValue = -maximizationResult.value
+                                val roundedValue = Math.floor(doubleValue + EPSILON)
+                                val intValue = roundedValue as int
+                                val oldBound = expressionToSaturate.upperBound
+                                if (oldBound === null || intValue <= oldBound) {
+                                        expressionToSaturate.upperBound = intValue
+                                        setBound(expressionToSaturate, constraints, roundedValue, columnUpperBounds, rowUpperBounds)
+                                } else {
+                                        throw new IllegalStateException("Unexpected increase of upper bound by " + (doubleValue - oldBound))
+                                }
+                        }
+                        case CbcResult.SOLUTION_UNBOUNDED: {
+                                if (expressionToSaturate.lowerBound !== null) {
+                                        throw new IllegalStateException("Finite upper bound became infinite")
+                                }
+                                expressionToSaturate.upperBound = null
+                                setBound(expressionToSaturate, constraints, Double.POSITIVE_INFINITY, columnUpperBounds, rowUpperBounds)
+                        }
+                        case CbcResult.UNSAT:
+                                if (lpRelaxation) {
+                                        return PolyhedronSaturationResult.EMPTY
+                                } else {
+                                        throw new RuntimeException("Minimization was SAT, but maximization is UNSAT")
+                                }
+                        case CbcResult.ABANDONED,
+                        case CbcResult.TIMEOUT:
+                                return PolyhedronSaturationResult.UNKNOWN
+                        default:
+                                throw new RuntimeException("Unknown CbcResult: " + maximizationResult)
+                }
+                return PolyhedronSaturationResult.SATURATED
+        }
+
+        private def toDouble(Integer nullableInt, double defaultValue) {
+                if (nullableInt === null) {
+                        defaultValue
+                } else {
+                        nullableInt.doubleValue
+                }
+        }
+
+        private def int getIndex(Dimension dimension) {
+                val index = dimensionsToIndicesMap.get(dimension)
+                if (index === null) {
+                        throw new IllegalArgumentException("Unknown dimension: " + dimension)
+                }
+                index
+        }
+
+        private def void setBound(LinearBoundedExpression expression, List<LinearConstraint> constraints, double bound,
+                double[] columnBounds, double[] rowBounds) {
+                switch (expression) {
+                        Dimension: {
+                                val j = getIndex(expression)
+                                columnBounds.set(j, bound)
+                        }
+                        LinearConstraint: {
+                                val i = constraints.indexOf(expression)
+                                if (i >= 0) {
+                                        rowBounds.set(i, bound)
+                                }
+                        }
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ExtendedLinearExpressionBuilderFactory.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ExtendedLinearExpressionBuilderFactory.xtend
new file mode 100644
index 00000000..e97fa5d7
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ExtendedLinearExpressionBuilderFactory.xtend
@@ -0,0 +1,140 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.ImmutableMap
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.HashSet
+import java.util.List
+import java.util.Map
+import java.util.Set
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+interface BoundSaturationListener {
+        def void boundsSaturated(Integer lower, Integer upper)
+}
+
+interface ExtendedLinearExpressionBuilderFactory {
+        def ExtendedLinearExpressionBuilder createBuilder()
+
+        def Dimension getDimension(IPatternMatch patternMatch)
+}
+
+interface ExtendedLinearExpressionBuilder extends LinearTypeExpressionBuilder {
+        override ExtendedLinearExpressionBuilder add(int scale, Type type)
+
+        def ExtendedLinearExpressionBuilder add(int scale, IPatternMatch patternMatch)
+
+        def ExtendedLinearExpressionBuilder add(int scale, Dimension dimension)
+
+        def LinearBoundedExpression build(BoundSaturationListener listener)
+}
+
+class ExtendedPolyhedronBuilder implements ExtendedLinearExpressionBuilderFactory {
+        val Map<Type, LinearBoundedExpression> typeBounds
+        val Map<Map<Dimension, Integer>, LinearBoundedExpression> expressionsCache
+
+        val ImmutableList.Builder<Dimension> dimensions = ImmutableList.builder
+        val Set<LinearConstraint> constraints = new HashSet
+        val Set<LinearBoundedExpression> expressionsToSaturate = new HashSet
+        val Map<IPatternMatch, Dimension> patternMatchCounts = new HashMap
+        @Accessors(PUBLIC_GETTER) val List<Pair<LinearBoundedExpression, BoundSaturationListener>> saturationListeners = new ArrayList
+
+        new(Polyhedron polyhedron, Map<Type, LinearBoundedExpression> typeBounds,
+                Map<Map<Dimension, Integer>, LinearBoundedExpression> initialExpressionsCache) {
+                this.typeBounds = typeBounds
+                this.expressionsCache = new HashMap(initialExpressionsCache)
+                dimensions.addAll(polyhedron.dimensions)
+                constraints.addAll(polyhedron.constraints)
+                expressionsToSaturate.addAll(polyhedron.expressionsToSaturate)
+        }
+
+        override createBuilder() {
+                new ExtendedLinearExpressionBuilderImpl(this)
+        }
+
+        override getDimension(IPatternMatch patternMatch) {
+                patternMatchCounts.computeIfAbsent(patternMatch) [ key |
+                        val dimension = new Dimension(key.toString, 0, null)
+                        dimensions.add(dimension)
+                        dimension
+                ]
+        }
+
+        def buildPolyhedron() {
+                new Polyhedron(
+                        dimensions.build,
+                        ImmutableList.copyOf(constraints),
+                        ImmutableList.copyOf(expressionsToSaturate)
+                )
+        }
+
+        @FinalFieldsConstructor
+        private static class ExtendedLinearExpressionBuilderImpl implements ExtendedLinearExpressionBuilder {
+                val ExtendedPolyhedronBuilder polyhedronBuilder
+
+                val Map<Dimension, Integer> coefficients = new HashMap
+
+                override add(int scale, Type type) {
+                        val expression = polyhedronBuilder.typeBounds.get(type)
+                        if (expression === null) {
+                                throw new IllegalArgumentException("Unknown Type: " + type)
+                        }
+                        add(scale, expression)
+                }
+
+                override add(int scale, IPatternMatch patternMatch) {
+                        val dimension = polyhedronBuilder.getDimension(patternMatch)
+                        add(scale, dimension)
+                }
+
+                private def add(int scale, LinearBoundedExpression expression) {
+                        switch (expression) {
+                                Dimension: add(scale, expression)
+                                LinearConstraint: add(scale, expression.coefficients)
+                                default: throw new IllegalArgumentException("Unknown LinearBoundedExpression: " + expression)
+                        }
+                }
+
+                private def add(int scale, Map<Dimension, Integer> coefficients) {
+                        for (pair : coefficients.entrySet) {
+                                add(scale * pair.value, pair.key)
+                        }
+                        this
+                }
+
+                override add(int scale, Dimension dimension) {
+                        coefficients.merge(dimension, scale)[a, b|a + b]
+                        this
+                }
+
+                override build() {
+                        val filteredCoefficients = ImmutableMap.copyOf(coefficients.filter [ x, coefficient |
+                                coefficient != 0
+                        ])
+                        polyhedronBuilder.expressionsCache.computeIfAbsent(filteredCoefficients) [ map |
+                                if (map.size == 1) {
+                                        val pair = map.entrySet.head
+                                        if (pair.value == 1) {
+                                                return pair.key
+                                        }
+                                }
+                                val constraint = new LinearConstraint(map)
+                                polyhedronBuilder.constraints.add(constraint)
+                                constraint
+                        ]
+                }
+
+                override build(BoundSaturationListener listener) {
+                        val expression = build()
+                        if (listener !== null) {
+                                polyhedronBuilder.expressionsToSaturate.add(expression)
+                                polyhedronBuilder.saturationListeners.add(expression -> listener)
+                        }
+                        expression
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ExtendedPolyhedronScopePropagatorStrategy.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ExtendedPolyhedronScopePropagatorStrategy.xtend
new file mode 100644
index 00000000..32923396
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ExtendedPolyhedronScopePropagatorStrategy.xtend
@@ -0,0 +1,63 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics
+import java.util.Collection
+import java.util.Map
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
+
+interface PolyhedronExtensionOperator {
+        def void extendPolyhedron(ExtendedLinearExpressionBuilderFactory factory)
+}
+
+class ExtendedPolyhedronScopePropagatorStrategy extends PolyhedronScopePropagatorStrategy {
+        val PolyhedronSolver solver
+        val Collection<PolyhedronExtensionOperator> extensionOperators
+
+        var Map<Type, LinearBoundedExpression> typeBounds
+        var Map<Map<Dimension, Integer>, LinearBoundedExpression> initialExpressionsCache
+
+        new(PolyhedronSolver solver, Collection<PolyhedronExtensionOperator> extensionOperators,
+                ModelGenerationStatistics statistics) {
+                super(statistics)
+                this.solver = solver
+                this.extensionOperators = extensionOperators
+        }
+
+        override setPolyhedron(Polyhedron polyhedron, Map<Type, LinearBoundedExpression> typeBounds,
+                Map<Map<Dimension, Integer>, LinearBoundedExpression> initialExpressionsCache) {
+                super.setPolyhedron(polyhedron, typeBounds, initialExpressionsCache)
+                this.typeBounds = typeBounds
+                this.initialExpressionsCache = initialExpressionsCache
+        }
+
+        override isRelevantRelation(Relation relation) {
+                true
+        }
+
+        override protected doSaturate() {
+                val builder = new ExtendedPolyhedronBuilder(polyhedron, typeBounds, initialExpressionsCache)
+                for (extensionOperator : extensionOperators) {
+                        extensionOperator.extendPolyhedron(builder)
+                }
+                val extendedPolyhedron = builder.buildPolyhedron()
+                val saturationOperator = solver.createSaturationOperator(extendedPolyhedron)
+                val result = try {
+                                saturationOperator.saturate()
+                        } finally {
+                                saturationOperator.close()
+                        }
+                if (result == PolyhedronSaturationResult.EMPTY) {
+                        // The partial model cannot be refined any more, we can't provide objective bounds.
+                        for (pair : builder.saturationListeners) {
+                                pair.value.boundsSaturated(null, null)
+                        }
+                        return false
+                }
+                for (pair : builder.saturationListeners) {
+                        val expression = pair.key
+                        pair.value.boundsSaturated(expression.lowerBound, expression.upperBound)
+                }
+                true
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/LinearTypeConstraintHint.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/LinearTypeConstraintHint.xtend
new file mode 100644
index 00000000..31f98e36
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/LinearTypeConstraintHint.xtend
@@ -0,0 +1,32 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PatternGenerator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import java.util.Map
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
+
+interface LinearTypeExpressionBuilderFactory {
+        def ViatraQueryMatcher<? extends IPatternMatch> createMatcher(String queryName)
+        
+        def LinearTypeExpressionBuilder createBuilder()
+}
+
+interface LinearTypeExpressionBuilder {
+        def LinearTypeExpressionBuilder add(int scale, Type type)
+
+        def LinearBoundedExpression build()
+}
+
+@FunctionalInterface
+interface RelationConstraintUpdater {
+        def void update(PartialInterpretation p)
+}
+
+interface LinearTypeConstraintHint {
+        def CharSequence getAdditionalPatterns(PatternGenerator patternGenerator, Map<String, PQuery> fqnToPQuery)
+        
+        def RelationConstraintUpdater createConstraintUpdater(LinearTypeExpressionBuilderFactory builderFactory)
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/MultiplicityGoalConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/MultiplicityGoalConstraintCalculator.xtend
new file mode 100644
index 00000000..273e0ac3
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/MultiplicityGoalConstraintCalculator.xtend
@@ -0,0 +1,57 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality

+

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

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

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

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

+

+class MultiplicityGoalConstraintCalculator {

+        val String targetRelationName

+        val IQuerySpecification<?> querySpecification

+        var MultiplicityCalculator<?> calculator

+        val boolean containment

+        val int lowerBound

+        val int cost

+                

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

+                if (lowerBound <= 0) {

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

+                }

+                this.targetRelationName = targetRelationName

+                this.querySpecification = querySpecification

+                this.calculator = null

+                this.containment = containment

+                this.lowerBound = lowerBound

+                this.cost = cost

+        }

+        

+        new(MultiplicityGoalConstraintCalculator other) {

+                this.targetRelationName = other.targetRelationName

+                this.querySpecification = other.querySpecification

+                this.calculator = null

+                this.containment = other.containment

+                this.lowerBound = other.lowerBound

+                this.cost = other.cost

+        }

+        

+        def getName() {

+                targetRelationName

+        }

+        

+        def isContainment() {

+                return containment

+        }

+

+        def init(Notifier notifier) {

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

+                val matcher = querySpecification.getMatcher(engine)

+                calculator = RemainingMultiplicityCalculator.of(matcher, lowerBound)

+        }

+        

+        def calculateValue() {

+                val res = calculator.multiplicity

+//              if(res>0)

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

+                return res*cost

+        }

+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronScopePropagator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronScopePropagator.xtend
new file mode 100644
index 00000000..ad8f94ab
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronScopePropagator.xtend
@@ -0,0 +1,522 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.ImmutableMap
+import com.google.common.collect.ImmutableSet
+import com.google.common.collect.Maps
+import com.google.common.collect.Sets
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.UnifinishedMultiplicityQueries
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialPrimitiveInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope
+import java.util.ArrayDeque
+import java.util.ArrayList
+import java.util.Collection
+import java.util.HashMap
+import java.util.HashSet
+import java.util.List
+import java.util.Map
+import java.util.Set
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.viatra.query.runtime.emf.EMFScope
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+class PolyhedronScopePropagator extends TypeHierarchyScopePropagator {
+        val boolean updateHeuristic
+        val Map<Scope, LinearBoundedExpression> scopeBounds
+        val LinearBoundedExpression topLevelBounds
+        val Polyhedron polyhedron
+        val PolyhedronScopePropagatorStrategy strategy
+        val Set<Relation> relevantRelations
+        List<RelationConstraintUpdater> updaters = emptyList
+
+        new(PartialInterpretation p, ModelGenerationStatistics statistics, Set<? extends Type> possibleNewDynamicTypes,
+                Map<RelationMultiplicityConstraint, UnifinishedMultiplicityQueries> unfinishedMultiplicityQueries,
+                IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hasElementInContainmentQuery,
+                Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allPatternsByName,
+                Collection<LinearTypeConstraintHint> hints, PolyhedronScopePropagatorStrategy strategy,
+                boolean propagateRelations, boolean updateHeuristic) {
+                super(p, statistics)
+                this.updateHeuristic = updateHeuristic
+                this.strategy = strategy
+                val builder = new PolyhedronBuilder(p)
+                builder.buildPolyhedron(possibleNewDynamicTypes)
+                scopeBounds = builder.scopeBounds
+                topLevelBounds = builder.topLevelBounds
+                polyhedron = builder.polyhedron
+                strategy.setPolyhedron(polyhedron, builder.typeBounds, builder.expressionsCache)
+                propagateAllScopeConstraints()
+                if (propagateRelations) {
+                        val maximumNumberOfNewNodes = topLevelBounds.upperBound
+                        if (maximumNumberOfNewNodes === null) {
+                                throw new IllegalStateException("Could not determine maximum number of new nodes, it may be unbounded")
+                        }
+                        if (maximumNumberOfNewNodes <= 0) {
+                                throw new IllegalStateException("Maximum number of new nodes is not positive")
+                        }
+                        builder.buildMultiplicityConstraints(unfinishedMultiplicityQueries, hasElementInContainmentQuery,
+                                allPatternsByName, hints, maximumNumberOfNewNodes)
+                        relevantRelations = builder.relevantRelations
+                        updaters = builder.updaters
+                } else {
+                        relevantRelations = emptySet
+                }
+        }
+
+        override void doPropagateAllScopeConstraints() {
+                super.doPropagateAllScopeConstraints()
+                resetBounds()
+                populatePolyhedronFromScope()
+//              println(polyhedron)
+                if (strategy.saturate) {
+                        populateScopesFromPolyhedron()
+                } else {
+                        setScopesInvalid()
+                }
+//              println(polyhedron)
+                if (updateHeuristic) {
+                        copyScopeBoundsToHeuristic()
+                }
+        }
+
+        override isPropagationNeededAfterAdditionToRelation(Relation r) {
+                relevantRelations.contains(r) || strategy.isRelevantRelation(r) || super.isPropagationNeededAfterAdditionToRelation(r)
+        }
+
+        override isQueryEngineFlushRequiredBeforePropagation() {
+                true
+        }
+
+        def resetBounds() {
+                for (dimension : polyhedron.dimensions) {
+                        dimension.lowerBound = 0
+                        dimension.upperBound = null
+                }
+                for (constraint : polyhedron.constraints) {
+                        constraint.lowerBound = null
+                        constraint.upperBound = null
+                }
+        }
+
+        private def populatePolyhedronFromScope() {
+                topLevelBounds.tightenLowerBound(partialInterpretation.minNewElements)
+                if (partialInterpretation.maxNewElements >= 0) {
+                        topLevelBounds.tightenUpperBound(partialInterpretation.maxNewElements)
+                }
+                for (pair : scopeBounds.entrySet) {
+                        val scope = pair.key
+                        val bounds = pair.value
+                        bounds.tightenLowerBound(scope.minNewElements)
+                        if (scope.maxNewElements >= 0) {
+                                bounds.tightenUpperBound(scope.maxNewElements)
+                        }
+                }
+                for (updater : updaters) {
+                        updater.update(partialInterpretation)
+                }
+        }
+
+        private def populateScopesFromPolyhedron() {
+                checkBounds(topLevelBounds)
+                if (partialInterpretation.minNewElements > topLevelBounds.lowerBound) {
+                        throw new IllegalArgumentException('''Lower bound of «topLevelBounds» smaller than top-level scope: «partialInterpretation.minNewElements»''')
+                } else if (partialInterpretation.minNewElements != topLevelBounds.lowerBound) {
+                        partialInterpretation.minNewElements = topLevelBounds.lowerBound
+                }
+                val topLevelUpperBound = topLevelBounds.upperBound ?: -1
+                if (partialInterpretation.maxNewElements >= 0 && topLevelUpperBound >= 0 &&
+                        partialInterpretation.maxNewElements < topLevelUpperBound) {
+                        throw new IllegalArgumentException('''Upper bound of «topLevelBounds» larger than top-level scope: «partialInterpretation.maxNewElements»''')
+                } else if (partialInterpretation.maxNewElements != topLevelUpperBound) {
+                        partialInterpretation.maxNewElements = topLevelUpperBound
+                }
+                for (pair : scopeBounds.entrySet) {
+                        val scope = pair.key
+                        val bounds = pair.value
+                        checkBounds(bounds)
+                        if (scope.minNewElements > bounds.lowerBound) {
+                                throw new IllegalArgumentException('''Lower bound of «bounds» smaller than «scope.targetTypeInterpretation» scope: «scope.minNewElements»''')
+                        } else if (scope.minNewElements != bounds.lowerBound) {
+                                scope.minNewElements = bounds.lowerBound
+                        }
+                        val upperBound = bounds.upperBound ?: -1
+                        if (scope.maxNewElements >= 0 && upperBound >= 0 && scope.maxNewElements < upperBound) {
+                                throw new IllegalArgumentException('''Upper bound of «bounds» larger than «scope.targetTypeInterpretation» scope: «scope.maxNewElements»''')
+                        } else if (scope.maxNewElements != upperBound) {
+                                scope.maxNewElements = upperBound
+                        }
+                }
+        }
+
+        private def checkBounds(LinearBoundedExpression bounds) {
+                if (bounds.lowerBound === null) {
+                        throw new IllegalArgumentException("Infinite lower bound: " + bounds)
+                } else if (bounds.lowerBound < 0) {
+                        throw new IllegalArgumentException("Negative lower bound: " + bounds)
+                }
+                if (bounds.upperBound !== null && bounds.upperBound < 0) {
+                        throw new IllegalArgumentException("Negative upper bound: " + bounds)
+                }
+        }
+
+        @FinalFieldsConstructor
+        private static class PolyhedronBuilder implements LinearTypeExpressionBuilderFactory {
+                static val INFINITY_SCALE = 10
+
+                val PartialInterpretation p
+
+                Map<Type, Dimension> instanceCounts
+                Map<Type, Map<Dimension, Integer>> subtypeDimensions
+                Map<Map<Dimension, Integer>, LinearBoundedExpression> expressionsCache
+                Map<Type, LinearBoundedExpression> typeBounds
+                int infinity
+                ViatraQueryEngine queryEngine
+                Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allPatternsByName
+                ImmutableList.Builder<RelationConstraintUpdater> updatersBuilder
+
+                Map<Scope, LinearBoundedExpression> scopeBounds
+                LinearBoundedExpression topLevelBounds
+                Polyhedron polyhedron
+                Set<Relation> relevantRelations
+                List<RelationConstraintUpdater> updaters
+
+                def buildPolyhedron(Set<? extends Type> possibleNewDynamicTypes) {
+                        instanceCounts = possibleNewDynamicTypes.toInvertedMap[new Dimension(name, 0, null)]
+                        val types = p.problem.types
+                        expressionsCache = Maps.newHashMapWithExpectedSize(types.size)
+                        subtypeDimensions = types.toInvertedMap[findSubtypeDimensions.toInvertedMap[1]]
+                        typeBounds = ImmutableMap.copyOf(subtypeDimensions.mapValues[toExpression])
+                        scopeBounds = buildScopeBounds
+                        topLevelBounds = instanceCounts.values.toInvertedMap[1].toExpression
+                        val dimensions = ImmutableList.copyOf(instanceCounts.values)
+                        val expressionsToSaturate = ImmutableList.copyOf(scopeBounds.values)
+                        polyhedron = new Polyhedron(dimensions, new ArrayList, expressionsToSaturate)
+                        addCachedConstraintsToPolyhedron()
+                }
+
+                def buildMultiplicityConstraints(
+                        Map<RelationMultiplicityConstraint, UnifinishedMultiplicityQueries> constraints,
+                        IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hasElementInContainmentQuery,
+                        Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> allPatternsByName,
+                        Collection<LinearTypeConstraintHint> hints, int maximumNuberOfNewNodes) {
+                        infinity = if (maximumNuberOfNewNodes <= Integer.MAX_VALUE / INFINITY_SCALE) {
+                                maximumNuberOfNewNodes * INFINITY_SCALE
+                        } else {
+                                Integer.MAX_VALUE
+                        }
+
+                        queryEngine = ViatraQueryEngine.on(new EMFScope(p))
+                        this.allPatternsByName = allPatternsByName
+                        updatersBuilder = ImmutableList.builder
+                        val containmentConstraints = constraints.entrySet.filter[key.containment].groupBy[key.targetType]
+                        for (pair : containmentConstraints.entrySet) {
+                                buildContainmentConstraints(pair.key, pair.value)
+                        }
+                        buildConstainmentRootConstraints(containmentConstraints.keySet, hasElementInContainmentQuery)
+                        for (pair : constraints.entrySet) {
+                                val constraint = pair.key
+                                if (!constraint.containment && !constraint.container) {
+                                        buildNonContainmentConstraints(constraint, pair.value)
+                                }
+                        }
+                        buildRelevantRelations(constraints.keySet)
+                        for (hint : hints) {
+                                val updater = hint.createConstraintUpdater(this)
+                                if (updater !== null) {
+                                        updatersBuilder.add(updater)
+                                }
+                        }
+                        updaters = updatersBuilder.build
+                        addCachedConstraintsToPolyhedron()
+                }
+
+                private def buildRelevantRelations(Set<RelationMultiplicityConstraint> constraints) {
+                        val builder = ImmutableSet.builder
+                        for (constraint : constraints) {
+                                builder.add(constraint.relation)
+                                if (constraint.inverseRelation !== null) {
+                                        builder.add(constraint.inverseRelation)
+                                }
+                        }
+                        relevantRelations = builder.build
+                }
+
+                private def addCachedConstraintsToPolyhedron() {
+                        val constraints = new HashSet
+                        constraints.addAll(expressionsCache.values.filter(LinearConstraint))
+                        constraints.removeAll(polyhedron.constraints)
+                        polyhedron.constraints.addAll(constraints)
+                }
+
+                private def buildContainmentConstraints(Type containedType,
+                        List<Map.Entry<RelationMultiplicityConstraint, UnifinishedMultiplicityQueries>> constraints) {
+                        val typeCoefficients = subtypeDimensions.get(containedType)
+                        val orphansLowerBoundCoefficients = new HashMap(typeCoefficients)
+                        val orphansUpperBoundCoefficients = new HashMap(typeCoefficients)
+                        val unfinishedMultiplicitiesBuilder = ImmutableList.builder
+                        val remainingContentsBuilder = ImmutableList.builder
+                        for (pair : constraints) {
+                                val constraint = pair.key
+                                val containerCoefficients = subtypeDimensions.get(constraint.sourceType)
+                                if (constraint.isUpperBoundFinite) {
+                                        orphansLowerBoundCoefficients.addCoefficients(-constraint.upperBound, containerCoefficients)
+                                } else {
+                                        orphansLowerBoundCoefficients.addCoefficients(-infinity, containerCoefficients)
+                                }
+                                orphansUpperBoundCoefficients.addCoefficients(-constraint.lowerBound, containerCoefficients)
+                                val queries = pair.value
+                                if (queries.existingMultiplicityQuery !== null) {
+                                        val matcher = queries.existingMultiplicityQuery.getMatcher(queryEngine)
+                                        if (constraint.constrainsUnfinished) {
+                                                unfinishedMultiplicitiesBuilder.add(
+                                                        RemainingMultiplicityCalculator.of(matcher, constraint.lowerBound))
+                                        }
+                                        remainingContentsBuilder.add(RemainingMultiplicityCalculator.of(matcher, constraint.upperBound))
+                                } else if (constraint.constrainsUnfinished) {
+                                        throw new IllegalArgumentException("Containment constraints need multiplicity queries")
+                                }
+                        }
+                        val orphanLowerBound = orphansLowerBoundCoefficients.toExpression
+                        val orphanUpperBound = orphansUpperBoundCoefficients.toExpression
+                        val updater = new ContainmentConstraintUpdater(orphanLowerBound, orphanUpperBound,
+                                unfinishedMultiplicitiesBuilder.build, remainingContentsBuilder.build)
+                        updatersBuilder.add(updater)
+                }
+
+                private def buildConstainmentRootConstraints(Set<Type> containedTypes,
+                        IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hasElementInContainmentQuery) {
+                        val matcher = hasElementInContainmentQuery.getMatcher(queryEngine)
+                        val rootDimensions = Sets.newHashSet(instanceCounts.values)
+                        for (type : containedTypes) {
+                                val containedDimensions = subtypeDimensions.get(type).keySet
+                                rootDimensions.removeAll(containedDimensions)
+                        }
+                        for (dimension : rootDimensions) {
+                                updatersBuilder.add(new ContainmentRootConstraintUpdater(dimension, matcher))
+                        }
+                }
+
+                private def buildNonContainmentConstraints(RelationMultiplicityConstraint constraint,
+                        UnifinishedMultiplicityQueries queries) {
+                        if (!constraint.reference) {
+                                return
+                        }
+                        if (constraint.constrainsRemainingInverse) {
+                                if (queries.getExistingMultiplicityQuery === null) {
+                                        throw new IllegalArgumentException("Reference constraints need unfinished multiplicity queries: " +
+                                                constraint.relation)
+                                }
+                                val existingMultiplicityMatcher = queries.getExistingMultiplicityQuery.getMatcher(queryEngine)
+                                val unfinishedMultiplicityCalculator = RemainingMultiplicityCalculator.of(existingMultiplicityMatcher,
+                                        constraint.lowerBound)
+                                val existingInverseMultiplicityMatcher = queries.existingInverseMultiplicityQuery.getMatcher(
+                                        queryEngine)
+                                val remainingInverseMultiplicityCalculator = new RemainingInverseMultiplicityCalculator(
+                                        existingInverseMultiplicityMatcher, constraint.upperBound)
+                                val availableMultiplicityCoefficients = new HashMap
+                                availableMultiplicityCoefficients.addCoefficients(constraint.inverseUpperBound,
+                                        subtypeDimensions.get(constraint.targetType))
+                                availableMultiplicityCoefficients.addCoefficients(-constraint.lowerBound,
+                                        subtypeDimensions.get(constraint.targetType))
+                                val availableMultiplicity = availableMultiplicityCoefficients.toExpression
+                                updatersBuilder.add(
+                                        new UnfinishedMultiplicityConstraintUpdater(availableMultiplicity, unfinishedMultiplicityCalculator,
+                                                remainingInverseMultiplicityCalculator))
+                        }
+                        if (constraint.constrainsUnrepairable) {
+                                if (queries.existingMultiplicityQuery.parameters.size < 5) {
+                                        throw new IllegalArgumentException("Reference constraints need repairable multiplicity queries: " +
+                                                constraint.relation)
+                                }
+                                val matcher = queries.existingMultiplicityQuery.getMatcher(queryEngine)
+                                val calculator = new UnrepairableMultiplicityCalculator(matcher, constraint.lowerBound)
+                                val targetTypeCardinality = typeBounds.get(constraint.targetType)
+                                updatersBuilder.add(new UnrepairableMultiplicityConstraintUpdater(targetTypeCardinality, calculator))
+                        }
+                }
+
+                private static def addCoefficients(Map<Dimension, Integer> accumulator, int scale, Map<Dimension, Integer> a) {
+                        for (pair : a.entrySet) {
+                                val dimension = pair.key
+                                val currentValue = accumulator.get(pair.key) ?: 0
+                                val newValue = currentValue + scale * pair.value
+                                if (newValue == 0) {
+                                        accumulator.remove(dimension)
+                                } else {
+                                        accumulator.put(dimension, newValue)
+                                }
+                        }
+                }
+
+                private def findSubtypeDimensions(Type type) {
+                        val subtypes = new HashSet
+                        val dimensions = new HashSet
+                        val stack = new ArrayDeque
+                        stack.addLast(type)
+                        while (!stack.empty) {
+                                val subtype = stack.removeLast
+                                if (subtypes.add(subtype)) {
+                                        val dimension = instanceCounts.get(subtype)
+                                        if (dimension !== null) {
+                                                dimensions.add(dimension)
+                                        }
+                                        stack.addAll(subtype.subtypes)
+                                }
+                        }
+                        dimensions
+                }
+
+                private def toExpression(Map<Dimension, Integer> coefficients) {
+                        expressionsCache.computeIfAbsent(coefficients) [ c |
+                                if (c.size == 1 && c.entrySet.head.value == 1) {
+                                        c.entrySet.head.key
+                                } else {
+                                        new LinearConstraint(c, null, null)
+                                }
+                        ]
+                }
+
+                private def buildScopeBounds() {
+                        val scopeBoundsBuilder = ImmutableMap.builder
+                        for (scope : p.scopes) {
+                                switch (targetTypeInterpretation : scope.targetTypeInterpretation) {
+                                        PartialPrimitiveInterpretation:
+                                                throw new IllegalStateException("Primitive type scopes are not yet implemented")
+                                        PartialComplexTypeInterpretation: {
+                                                val complexType = targetTypeInterpretation.interpretationOf
+                                                val typeBound = typeBounds.get(complexType)
+                                                if (typeBound === null) {
+                                                        if (scope.minNewElements > 0) {
+                                                                throw new IllegalArgumentException("Found scope for " + complexType.name +
+                                                                        ", but the type cannot be instantiated")
+                                                        }
+                                                } else {
+                                                        scopeBoundsBuilder.put(scope, typeBound)
+                                                }
+                                        }
+                                        default:
+                                                throw new IllegalArgumentException("Unknown PartialTypeInterpretation: " +
+                                                        targetTypeInterpretation)
+                                }
+                        }
+                        scopeBoundsBuilder.build
+                }
+
+                override createMatcher(String queryName) {
+                        val querySpecification = allPatternsByName.get(queryName)
+                        if (querySpecification === null) {
+                                throw new IllegalArgumentException("Unknown pattern: " + queryName)
+                        }
+                        querySpecification.getMatcher(queryEngine)
+                }
+
+                override createBuilder() {
+                        new PolyhedronBuilderLinearTypeExpressionBuilder(this)
+                }
+        }
+
+        @FinalFieldsConstructor
+        private static class PolyhedronBuilderLinearTypeExpressionBuilder implements LinearTypeExpressionBuilder {
+                val PolyhedronBuilder polyhedronBuilder
+                val Map<Dimension, Integer> coefficients = new HashMap
+
+                override add(int scale, Type type) {
+                        val typeCoefficients = polyhedronBuilder.subtypeDimensions.get(type)
+                        if (typeCoefficients === null) {
+                                throw new IllegalArgumentException("Unknown type: " + type)
+                        }
+                        PolyhedronBuilder.addCoefficients(coefficients, scale, typeCoefficients)
+                        this
+                }
+
+                override build() {
+                        polyhedronBuilder.toExpression(coefficients)
+                }
+        }
+
+        @FinalFieldsConstructor
+        private static class ContainmentConstraintUpdater implements RelationConstraintUpdater {
+                val LinearBoundedExpression orphansLowerBound
+                val LinearBoundedExpression orphansUpperBound
+                val List<MultiplicityCalculator<? extends IPatternMatch>> unfinishedMultiplicities
+                val List<MultiplicityCalculator<? extends IPatternMatch>> remainingContents
+
+                override update(PartialInterpretation p) {
+                        tightenLowerBound(p)
+                        tightenUpperBound(p)
+                }
+
+                private def tightenLowerBound(PartialInterpretation p) {
+                        var int sum = 0
+                        for (calculator : remainingContents) {
+                                val value = calculator.getMultiplicity(p)
+                                if (value < 0) {
+                                        // Infinite upper bound, no need to tighten.
+                                        return
+                                }
+                                sum += value
+                        }
+                        orphansLowerBound.tightenUpperBound(sum)
+                }
+
+                private def tightenUpperBound(PartialInterpretation p) {
+                        var int sum = 0
+                        for (calculator : unfinishedMultiplicities) {
+                                val value = calculator.getMultiplicity(p)
+                                sum += value
+                        }
+                        orphansUpperBound.tightenLowerBound(sum)
+                }
+        }
+
+        @FinalFieldsConstructor
+        private static class ContainmentRootConstraintUpdater implements RelationConstraintUpdater {
+                val LinearBoundedExpression typeCardinality
+                val ViatraQueryMatcher<? extends IPatternMatch> hasElementInContainmentMatcher
+
+                override update(PartialInterpretation p) {
+                        if (hasElementInContainmentMatcher.hasMatch(p)) {
+                                typeCardinality.tightenUpperBound(0)
+                        } else {
+                                typeCardinality.tightenUpperBound(1)
+                        }
+                }
+
+                private static def <T extends IPatternMatch> hasMatch(ViatraQueryMatcher<T> matcher, PartialInterpretation p) {
+                        val match = matcher.newMatch(p.problem, p)
+                        matcher.countMatches(match) != 0
+                }
+        }
+
+        @FinalFieldsConstructor
+        private static class UnfinishedMultiplicityConstraintUpdater implements RelationConstraintUpdater {
+                val LinearBoundedExpression availableMultiplicityExpression
+                val MultiplicityCalculator<? extends IPatternMatch> unfinishedMultiplicityCalculator
+                val MultiplicityCalculator<? extends IPatternMatch> remainingInverseMultiplcityCalculator
+
+                override update(PartialInterpretation p) {
+                        val unfinishedMultiplicity = unfinishedMultiplicityCalculator.getMultiplicity(p)
+                        val remainingInverseMultiplicity = remainingInverseMultiplcityCalculator.getMultiplicity(p)
+                        val int requiredMultiplicity = unfinishedMultiplicity - remainingInverseMultiplicity
+                        availableMultiplicityExpression.tightenLowerBound(requiredMultiplicity)
+                }
+        }
+
+        @FinalFieldsConstructor
+        private static class UnrepairableMultiplicityConstraintUpdater implements RelationConstraintUpdater {
+                val LinearBoundedExpression targetCardinalityExpression
+                val MultiplicityCalculator<? extends IPatternMatch> calculator
+
+                override update(PartialInterpretation p) {
+                        val value = calculator.getMultiplicity(p)
+                        targetCardinalityExpression.tightenLowerBound(value)
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronScopePropagatorStrategy.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronScopePropagatorStrategy.xtend
new file mode 100644
index 00000000..f93dcd18
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronScopePropagatorStrategy.xtend
@@ -0,0 +1,92 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import com.google.common.cache.Cache
+import com.google.common.cache.CacheBuilder
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics
+import java.util.Map
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+@FinalFieldsConstructor
+abstract class PolyhedronScopePropagatorStrategy {
+        val ModelGenerationStatistics statistics
+
+        @Accessors(PUBLIC_GETTER) var Polyhedron polyhedron
+
+        def void setPolyhedron(Polyhedron polyhedron, Map<Type, LinearBoundedExpression> typeBounds,
+                Map<Map<Dimension, Integer>, LinearBoundedExpression> initialExpressionsCache) {
+                if (this.polyhedron !== null) {
+                        throw new IllegalStateException("polyhedron was already set")
+                }
+                this.polyhedron = polyhedron
+                initialize()
+        }
+
+        def boolean saturate() {
+                if (polyhedron === null) {
+                        throw new IllegalStateException("polyhedron was not set")
+                }
+                doSaturate()
+        }
+        
+        def boolean isRelevantRelation(Relation relation) {
+                false
+        }
+
+        protected def incrementScopePropagationSolverCount() {
+                statistics.incrementScopePropagationSolverCount()
+        }
+
+        protected def void initialize() {
+        }
+
+        protected def boolean doSaturate()
+}
+
+@FinalFieldsConstructor
+class CachingSimplePolyhedronScopePropagatorStrategy extends PolyhedronScopePropagatorStrategy {
+        static val CACHE_SIZE = 10000
+
+        val PolyhedronSolver solver
+
+        val Cache<PolyhedronSignature, PolyhedronSignature> cache = CacheBuilder.newBuilder.maximumSize(CACHE_SIZE).build
+        var PolyhedronSaturationOperator operator
+
+        new(PolyhedronSolver solver, ModelGenerationStatistics statistics) {
+                super(statistics)
+                this.solver = solver
+        }
+
+        override protected initialize() {
+                operator = solver.createSaturationOperator(polyhedron)
+        }
+
+        override protected doSaturate() {
+                val signature = polyhedron.createSignature
+                val cachedSignature = cache.getIfPresent(signature)
+                switch (cachedSignature) {
+                        case null: {
+                                incrementScopePropagationSolverCount()
+                                val result = operator.saturate()
+                                if (result == PolyhedronSaturationResult.EMPTY) {
+                                        cache.put(signature, PolyhedronSignature.EMPTY)
+                                        false
+                                } else {
+                                        val resultSignature = polyhedron.createSignature
+                                        cache.put(signature, resultSignature)
+                                        true
+                                }
+                        }
+                        case PolyhedronSignature.EMPTY:
+                                false
+                        PolyhedronSignature.Bounds: {
+                                polyhedron.applySignature(signature)
+                                true
+                        }
+                        default:
+                                throw new IllegalStateException("Unknown polyhedron signature: " + signature)
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronSolver.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronSolver.xtend
new file mode 100644
index 00000000..21bd2d9e
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/PolyhedronSolver.xtend
@@ -0,0 +1,186 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import java.util.List
+import java.util.Map
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.Data
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+interface PolyhedronSolver {
+        def PolyhedronSaturationOperator createSaturationOperator(Polyhedron polyhedron)
+}
+
+enum PolyhedronSaturationResult {
+        SATURATED,
+        EMPTY,
+        UNKNOWN
+}
+
+interface PolyhedronSaturationOperator extends AutoCloseable {
+        def Polyhedron getPolyhedron()
+
+        def PolyhedronSaturationResult saturate()
+}
+
+@FinalFieldsConstructor
+@Accessors
+class Polyhedron {
+        /**
+         * The list of dimensions (variables) for this polyhedron.
+         * 
+         * This list must not be modified after the polyhedron was created.
+         * However, lower and upper bounds of the dimensions may be changed.
+         * 
+         * Names of dimensions in this list are assumed to be unique.
+         */
+        val List<Dimension> dimensions
+
+        /**
+         * The list of constraints defining this polyhedron.
+         * 
+         * The list and its elements may be freely modified.
+         */
+        val List<LinearConstraint> constraints
+
+        /**
+         * The list of constraints that should be saturated (tightened)
+         * when a {@link PolyhedronSaturationOperator} is invoked.
+         * 
+         * This list may be freely modified.
+         * 
+         * Place all dimensions and constraints here to saturate all the bounds.
+         */
+        val List<LinearBoundedExpression> expressionsToSaturate
+
+        override toString() '''
+                Dimensions:
+                        «FOR dimension : dimensions»
+                                «dimension»
+                        «ENDFOR»
+                Constraints:
+                        «FOR constraint : constraints»
+                                «constraint»
+                        «ENDFOR»
+        '''
+
+        def createSignature() {
+                val size = dimensions.size + constraints.size
+                val lowerBounds = newArrayOfSize(size)
+                val upperBounds = newArrayOfSize(size)
+                var int i = 0
+                for (dimension : dimensions) {
+                        lowerBounds.set(i, dimension.lowerBound)
+                        upperBounds.set(i, dimension.upperBound)
+                        i++
+                }
+                for (constraint : constraints) {
+                        lowerBounds.set(i, constraint.lowerBound)
+                        upperBounds.set(i, constraint.upperBound)
+                        i++
+                }
+                new PolyhedronSignature.Bounds(lowerBounds, upperBounds)
+        }
+
+        def applySignature(PolyhedronSignature.Bounds signature) {
+                val lowerBounds = signature.lowerBounds
+                val upperBounds = signature.upperBounds
+                var int i = 0
+                for (dimension : dimensions) {
+                        dimension.lowerBound = lowerBounds.get(i)
+                        dimension.upperBound = upperBounds.get(i)
+                        i++
+                }
+                for (constraint : constraints) {
+                        constraint.lowerBound = lowerBounds.get(i)
+                        constraint.upperBound = upperBounds.get(i)
+                        i++
+                }
+        }
+}
+
+abstract class PolyhedronSignature {
+        public static val EMPTY = new PolyhedronSignature {
+                override toString() {
+                        "PolyhedronSignature.EMPTY"
+                }
+        }
+
+        private new() {
+        }
+
+        @Data
+        static class Bounds extends PolyhedronSignature {
+                val Integer[] lowerBounds
+                val Integer[] upperBounds
+        }
+}
+
+@Accessors
+class Bounds {
+        var Integer lowerBound
+        var Integer upperBound
+
+        def void tightenLowerBound(Integer tighterBound) {
+                if (lowerBound === null || (tighterBound !== null && lowerBound < tighterBound)) {
+                        lowerBound = tighterBound
+                }
+        }
+
+        def void tightenUpperBound(Integer tighterBound) {
+                if (upperBound === null || (tighterBound !== null && upperBound > tighterBound)) {
+                        upperBound = tighterBound
+                }
+        }
+
+        def void assertBetween(Integer tighterLowerBound, Integer tighterUpperBound) {
+                tightenLowerBound(tighterLowerBound)
+                tightenUpperBound(tighterUpperBound)
+        }
+
+        def void assertEqualsTo(int bound) {
+                assertBetween(bound, bound)
+        }
+}
+
+abstract class LinearBoundedExpression extends Bounds {
+}
+
+@Accessors
+class Dimension extends LinearBoundedExpression {
+        val String name
+
+        @FinalFieldsConstructor
+        new() {
+        }
+
+        new(String name, Integer lowerBound, Integer upperBound) {
+                this(name)
+                this.lowerBound = lowerBound
+                this.upperBound = upperBound
+        }
+
+        override toString() {
+                '''«IF lowerBound !== null»«lowerBound» <= «ENDIF»«name»«IF upperBound !== null» <= «upperBound»«ENDIF»'''
+        }
+
+}
+
+@Accessors
+class LinearConstraint extends LinearBoundedExpression {
+        val Map<Dimension, Integer> coefficients
+
+        @FinalFieldsConstructor
+        new() {
+        }
+
+        new(Map<Dimension, Integer> coefficients, Integer lowerBound, Integer upperBound) {
+                this(coefficients)
+                this.lowerBound = lowerBound
+                this.upperBound = upperBound
+        }
+
+        override toString() {
+                '''«IF lowerBound !== null»«lowerBound» <= «ENDIF»«FOR pair : coefficients.entrySet SEPARATOR " + "»«IF pair.value != 1»«pair.value» * «ENDIF»«pair.key.name»«ENDFOR»«IF upperBound !== null» <= «upperBound»«ENDIF»'''
+        }
+
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/RelationConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/RelationConstraintCalculator.xtend
new file mode 100644
index 00000000..abf65be3
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/RelationConstraintCalculator.xtend
@@ -0,0 +1,156 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.ImmutableSet
+import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion
+import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion
+import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.UpperMultiplicityAssertion
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
+import java.util.HashMap
+import java.util.List
+import org.eclipse.xtend.lib.annotations.Data
+
+@Data
+class RelationConstraints {
+        val List<RelationMultiplicityConstraint> multiplicityConstraints
+}
+
+@Data
+class RelationMultiplicityConstraint {
+        Relation relation
+        Relation inverseRelation
+        boolean containment
+        boolean container
+        int lowerBound
+        int upperBound
+        int inverseUpperBound
+
+        def isUpperBoundFinite() {
+                upperBound >= 0
+        }
+
+        private def isInverseUpperBoundFinite() {
+                inverseUpperBound >= 0
+        }
+
+        private def canHaveMultipleSourcesPerTarget() {
+                inverseUpperBound != 1
+        }
+
+        def constrainsUnfinished() {
+                lowerBound >= 1 && (!container || lowerBound >= 2)
+        }
+
+        def constrainsUnrepairable() {
+                // TODO Optimize the unrepairable matches computation,
+                // or come up with a heuristic when does computing unrepairables worth the overhead.
+                false && constrainsUnfinished && canHaveMultipleSourcesPerTarget && reference
+        }
+
+        def constrainsRemainingInverse() {
+                lowerBound >= 1 && !containment && !container && inverseUpperBoundFinite && reference
+        }
+
+        def constrainsRemainingContents() {
+                containment
+        }
+
+        def isActive() {
+                constrainsUnfinished || constrainsUnrepairable || constrainsRemainingInverse || constrainsRemainingContents
+        }
+
+        def isSourceTypeComplex() {
+                getParamTypeReference(0) instanceof ComplexTypeReference
+        }
+        
+        def isTargetTypeComplex() {
+                getParamTypeReference(1) instanceof ComplexTypeReference
+        }
+        
+        def isReference() {
+                sourceTypeComplex && targetTypeComplex
+        }
+
+        def getSourceType() {
+                getParamType(0)
+        }
+
+        def getTargetType() {
+                getParamType(1)
+        }
+
+        private def getParamTypeReference(int i) {
+                val parameters = relation.parameters
+                if (i < parameters.size) {
+                        return parameters.get(i)
+                }
+                throw new IllegalArgumentException("Argument index out of range")
+        }
+        
+        private def getParamType(int i) {
+                val reference = getParamTypeReference(i)
+                if (reference instanceof ComplexTypeReference) {
+                        return reference.referred
+                }
+                throw new IllegalArgumentException("Constraint with primitive type")
+        }
+}
+
+class RelationConstraintCalculator {
+        def calculateRelationConstraints(LogicProblem problem) {
+                val containmentRelations = switch (problem.containmentHierarchies.size) {
+                        case 0:
+                                <Relation>emptySet
+                        case 1:
+                                ImmutableSet.copyOf(problem.containmentHierarchies.head.containmentRelations)
+                        default:
+                                throw new IllegalArgumentException("Only a single containment hierarchy is supported")
+                }
+                val inverseRelations = new HashMap<Relation, Relation>
+                val lowerMultiplicities = new HashMap<Relation, Integer>
+                val upperMultiplicities = new HashMap<Relation, Integer>
+                for (relation : problem.relations) {
+                        lowerMultiplicities.put(relation, 0)
+                        upperMultiplicities.put(relation, -1)
+                }
+                for (annotation : problem.annotations) {
+                        switch (annotation) {
+                                InverseRelationAssertion: {
+                                        inverseRelations.put(annotation.inverseA, annotation.inverseB)
+                                        inverseRelations.put(annotation.inverseB, annotation.inverseA)
+                                }
+                                LowerMultiplicityAssertion:
+                                        lowerMultiplicities.put(annotation.relation, annotation.lower)
+                                UpperMultiplicityAssertion:
+                                        upperMultiplicities.put(annotation.relation, annotation.upper)
+                        }
+                }
+                val multiplicityConstraintsBuilder = ImmutableList.builder()
+                for (relation : problem.relations) {
+                        val containment = containmentRelations.contains(relation)
+                        val lowerMultiplicity = lowerMultiplicities.get(relation)
+                        val upperMultiplicity = upperMultiplicities.get(relation)
+                        var container = false
+                        var inverseUpperMultiplicity = -1
+                        val inverseRelation = inverseRelations.get(relation)
+                        if (inverseRelation !== null) {
+                                inverseUpperMultiplicity = upperMultiplicities.get(inverseRelation)
+                                container = containmentRelations.contains(inverseRelation)
+                        }
+                        if (containment) {
+                                inverseUpperMultiplicity = 1
+                        }
+                        val constraint = new RelationMultiplicityConstraint(relation, inverseRelation, containment, container,
+                                lowerMultiplicity, upperMultiplicity, inverseUpperMultiplicity)
+                        if (constraint.isActive) {
+                                if (relation.parameters.size != 2) {
+                                        throw new IllegalArgumentException('''Relation «relation.name» has multiplicity or containment constraints, but it is not binary''')
+                                }
+                                multiplicityConstraintsBuilder.add(constraint)
+                        }
+                }
+                new RelationConstraints(multiplicityConstraintsBuilder.build)
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/RemainingMultiplicityCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/RemainingMultiplicityCalculator.xtend
new file mode 100644
index 00000000..48b52d28
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/RemainingMultiplicityCalculator.xtend
@@ -0,0 +1,111 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import java.util.Iterator
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+@FinalFieldsConstructor
+abstract class MultiplicityCalculator<Match extends IPatternMatch> {
+        val ViatraQueryMatcher<Match> matcher
+
+        def getMultiplicity() {
+                val iterator = matcher.streamAllMatches.iterator
+                getMultiplicity(iterator)
+        }
+        
+        def getMultiplicity(PartialInterpretation interpretation) {
+                val partialMatch = matcher.newEmptyMatch
+                partialMatch.set(0, interpretation.problem)
+                partialMatch.set(1, interpretation)
+                val iterator = matcher.streamAllMatches(partialMatch).iterator
+                getMultiplicity(iterator)
+        }
+
+        protected def int getMultiplicity(Iterator<? extends Match> iterator)
+}
+
+class RemainingMultiplicityCalculator<Match extends IPatternMatch> extends MultiplicityCalculator<Match> {
+        val int bound
+
+        @FinalFieldsConstructor
+        private new() {
+        }
+
+        protected override getMultiplicity(Iterator<? extends Match> iterator) {
+                var res = 0
+                while (iterator.hasNext) {
+                        val match = iterator.next
+                        val existingMultiplicity = match.get(3) as Integer
+                        if (existingMultiplicity < bound) {
+                                res += bound - existingMultiplicity
+                        }
+                }
+                res
+        }
+        
+        static def <Match extends IPatternMatch> of(ViatraQueryMatcher<Match> matcher, int bound) {
+                if (bound < 0) {
+                        new RemainingInfiniteMultiplicityCalculator(matcher)
+                } else {
+                        new RemainingMultiplicityCalculator(matcher, bound)
+                }
+        }
+}
+
+package class RemainingInfiniteMultiplicityCalculator<Match extends IPatternMatch> extends MultiplicityCalculator<Match> {
+        
+        @FinalFieldsConstructor
+        package new() {
+        }
+        
+        protected override getMultiplicity(Iterator<? extends Match> iterator) {
+                if (iterator.hasNext) {
+                        -1
+                } else {
+                        0
+                }
+        }
+}
+
+@FinalFieldsConstructor
+class UnrepairableMultiplicityCalculator<Match extends IPatternMatch> extends MultiplicityCalculator<Match> {
+        val int lowerBound
+        
+        override protected getMultiplicity(Iterator<? extends Match> iterator) {
+                var res = 0
+                while (iterator.hasNext) {
+                        val match = iterator.next
+                        val existingMultiplicity = match.get(3) as Integer
+                        if (existingMultiplicity < lowerBound) {
+                                val missingMultiplcity = lowerBound - existingMultiplicity
+                                val numerOfRepairMatches = match.get(4) as Integer
+                                val unrepairableMultiplicty = missingMultiplcity - numerOfRepairMatches
+                                if (unrepairableMultiplicty > res) {
+                                        res = unrepairableMultiplicty
+                                }
+                        }
+                }
+                res
+        }
+}
+
+@FinalFieldsConstructor
+class RemainingInverseMultiplicityCalculator<Match extends IPatternMatch> extends MultiplicityCalculator<Match> {
+        val int upperBound
+        
+        override protected getMultiplicity(Iterator<? extends Match> iterator) {
+                var res = 0
+                while (iterator.hasNext) {
+                        val match = iterator.next
+                        val existingMultiplicity = match.get(3) as Integer
+                        if (existingMultiplicity < upperBound) {
+                                val availableMultiplicity = upperBound - existingMultiplicity
+                                val numberOfRepairMatches = match.get(4) as Integer
+                                res += Math.min(availableMultiplicity, numberOfRepairMatches)
+                        }
+                }
+                res
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagator.xtend
new file mode 100644
index 00000000..cacba3c6
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagator.xtend
@@ -0,0 +1,161 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality

+

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

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

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

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

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

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

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

+import java.util.HashMap

+import java.util.HashSet

+import java.util.Map

+import java.util.Set

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

+

+class ScopePropagator {

+        @Accessors(PROTECTED_GETTER) val PartialInterpretation partialInterpretation

+        @Accessors(PROTECTED_GETTER) val ModelGenerationStatistics statistics

+        val Map<PartialTypeInterpratation, Scope> type2Scope

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

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

+        

+        @Accessors(PUBLIC_GETTER) var scopePropagationNeeded = false

+

+        new(PartialInterpretation p, ModelGenerationStatistics statistics) {

+                partialInterpretation = p

+                this.statistics = statistics

+                type2Scope = new HashMap

+                for (scope : p.scopes) {

+                        type2Scope.put(scope.targetTypeInterpretation, scope)

+                }

+

+                superScopes = new HashMap

+                subScopes = new HashMap

+                for (scope : p.scopes) {

+                        superScopes.put(scope, new HashSet)

+                        subScopes.put(scope, new HashSet)

+                }

+

+                for (scope : p.scopes) {

+                        val target = scope.targetTypeInterpretation

+                        if (target instanceof PartialComplexTypeInterpretation) {

+                                val supertypeInterpretations = target.supertypeInterpretation

+                                for (supertypeInterpretation : supertypeInterpretations) {

+                                        val supertypeScope = type2Scope.get(supertypeInterpretation)

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

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

+                                }

+                        }

+                }

+                var boolean changed

+                do {

+                        changed = false

+                        for (scope : p.scopes) {

+                                val subScopeSet = subScopes.get(scope)

+                                val superScopeSet = superScopes.get(scope)

+                                for (subScope : subScopeSet) {

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

+                                }

+                                for (superScope : superScopeSet) {

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

+                                }

+                        }

+                } while (changed)

+

+                copyScopeBoundsToHeuristic()

+        }

+

+        def void propagateAllScopeConstraints() {

+                scopePropagationNeeded = false

+                if (!valid) {

+                        return

+                }

+                statistics.incrementScopePropagationCount()

+                doPropagateAllScopeConstraints()

+        }

+

+        def isValid() {

+                partialInterpretation.maxNewElements == -1 ||

+                        partialInterpretation.minNewElements <= partialInterpretation.maxNewElements

+        }

+

+        protected def copyScopeBoundsToHeuristic() {

+                partialInterpretation.minNewElementsHeuristic = partialInterpretation.minNewElements

+                for (scope : partialInterpretation.scopes) {

+                        scope.minNewElementsHeuristic = scope.minNewElements

+                }

+        }

+

+        protected def void doPropagateAllScopeConstraints() {

+                // Nothing to propagate.

+        }

+

+        def decrementTypeScope(PartialTypeInterpratation t) {

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

+                if (isPrimitive) {

+                        return

+                }

+                scopePropagationNeeded = true

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

+                val targetScope = type2Scope.get(t)

+                if (targetScope !== null) {

+                        targetScope.removeOne

+                        val sups = superScopes.get(targetScope)

+                        sups.forEach[removeOne]

+                }

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

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

+                }

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

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

+                }

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

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

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

+                        setScopesInvalid()

+                }

+

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

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

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

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

+        }

+        

+        def addedToRelation(Relation r) {

+                if (isPropagationNeededAfterAdditionToRelation(r)) {

+                        scopePropagationNeeded = true

+                }

+        }

+

+        protected def setScopesInvalid() {

+                partialInterpretation.minNewElements = Integer.MAX_VALUE

+                partialInterpretation.maxNewElements = 0

+                for (scope : partialInterpretation.scopes) {

+                        scope.minNewElements = Integer.MAX_VALUE

+                        scope.maxNewElements = 0

+                }

+        }

+

+        protected def isPropagationNeededAfterAdditionToRelation(Relation r) {

+                false

+        }

+        

+        def isQueryEngineFlushRequiredBeforePropagation() {

+                false

+        }

+

+        private def removeOne(Scope scope) {

+                if (scope.minNewElements > 0) {

+                        scope.minNewElements = scope.minNewElements - 1

+                }

+                if (scope.minNewElementsHeuristic > 0) {

+                        scope.minNewElementsHeuristic = scope.minNewElementsHeuristic - 1

+                }

+                if (scope.maxNewElements > 0) {

+                        scope.maxNewElements = scope.maxNewElements - 1

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

+                        setScopesInvalid()

+                }

+        }

+}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagatorStrategy.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagatorStrategy.xtend
new file mode 100644
index 00000000..3165917a
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/ScopePropagatorStrategy.xtend
@@ -0,0 +1,71 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import org.eclipse.xtend.lib.annotations.Data
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+enum PolyhedralScopePropagatorConstraints {
+        TypeHierarchy,
+        Relational
+}
+
+enum PolyhedralScopePropagatorSolver {
+        Z3Real,
+        Z3Integer,
+        Cbc,
+        Clp
+}
+
+abstract class ScopePropagatorStrategy {
+        public static val None = new Simple("None")
+        
+        public static val Basic = new Simple("Basic")
+
+        public static val BasicTypeHierarchy = new Simple("BasicTypeHierarchy")
+
+        private new() {
+        }
+
+        def boolean requiresUpperBoundIndexing()
+
+        static class Simple extends ScopePropagatorStrategy {
+                val String name
+
+                @FinalFieldsConstructor
+                private new() {
+                }
+
+                override requiresUpperBoundIndexing() {
+                        false
+                }
+
+                override toString() {
+                        name
+                }
+        }
+
+        @Data
+        static class Polyhedral extends ScopePropagatorStrategy {
+                public static val UNLIMITED_TIME = -1
+
+                val PolyhedralScopePropagatorConstraints constraints
+                val PolyhedralScopePropagatorSolver solver
+                val boolean updateHeuristic
+                val double timeoutSeconds
+
+                @FinalFieldsConstructor
+                new() {
+                }
+
+                new(PolyhedralScopePropagatorConstraints constraints, PolyhedralScopePropagatorSolver solver, boolean updateHeuristic) {
+                        this(constraints, solver, updateHeuristic, UNLIMITED_TIME)
+                }
+                
+                new(PolyhedralScopePropagatorConstraints constraints, PolyhedralScopePropagatorSolver solver) {
+                        this(constraints, solver, true)
+                }
+
+                override requiresUpperBoundIndexing() {
+                        constraints == PolyhedralScopePropagatorConstraints.Relational
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/TypeHierarchyScopePropagator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/TypeHierarchyScopePropagator.xtend
new file mode 100644
index 00000000..d1704b39
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/TypeHierarchyScopePropagator.xtend
@@ -0,0 +1,85 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope
+
+class TypeHierarchyScopePropagator extends ScopePropagator {
+
+        new(PartialInterpretation p, ModelGenerationStatistics statistics) {
+                super(p, statistics)
+        }
+
+        protected override doPropagateAllScopeConstraints() {
+                var boolean hadChanged
+                do {
+                        hadChanged = false
+                        for (superScopeEntry : superScopes.entrySet) {
+                                val sub = superScopeEntry.key
+                                hadChanged = propagateLowerLimitUp(sub, partialInterpretation) || hadChanged
+                                hadChanged = propagateUpperLimitDown(sub, partialInterpretation) || hadChanged
+                                for (sup : superScopeEntry.value) {
+                                        hadChanged = propagateLowerLimitUp(sub, sup) || hadChanged
+                                        hadChanged = propagateUpperLimitDown(sub, sup) || hadChanged
+                                }
+                        }
+                } while (hadChanged)
+        }
+
+        private def propagateLowerLimitUp(Scope subScope, Scope superScope) {
+                var changed = false
+                if (subScope.minNewElements > superScope.minNewElements) {
+                        superScope.minNewElements = subScope.minNewElements
+                        changed = true
+                }
+                if (subScope.minNewElementsHeuristic > superScope.minNewElementsHeuristic) {
+                        superScope.minNewElementsHeuristic = subScope.minNewElementsHeuristic
+                        changed = true
+                }
+                changed
+        }
+
+        private def propagateUpperLimitDown(Scope subScope, Scope superScope) {
+                if (superScope.maxNewElements >= 0 &&
+                        (superScope.maxNewElements < subScope.maxNewElements || subScope.maxNewElements < 0)) {
+//                      println('''
+//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> «(superScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name»
+//                      subScope.maxNewElements «subScope.maxNewElements» = superScope.maxNewElements «superScope.maxNewElements»
+//                      ''')
+                        subScope.maxNewElements = superScope.maxNewElements
+                        return true
+                } else {
+                        return false
+                }
+        }
+
+        private def propagateLowerLimitUp(Scope subScope, PartialInterpretation p) {
+                var changed = false
+                if (subScope.minNewElements > p.minNewElements) {
+//                      println('''
+//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> nodes
+//                      p.minNewElements «p.minNewElements» = subScope.minNewElements «subScope.minNewElements»
+//                      ''')
+                        p.minNewElements = subScope.minNewElements
+                        changed = true
+                }
+                if (subScope.minNewElementsHeuristic > p.minNewElementsHeuristic) {
+                        p.minNewElementsHeuristic = subScope.minNewElementsHeuristic
+                        changed = true
+                }
+                changed
+        }
+
+        private def propagateUpperLimitDown(Scope subScope, PartialInterpretation p) {
+                if (p.maxNewElements >= 0 && (p.maxNewElements < subScope.maxNewElements || subScope.maxNewElements < 0)) {
+//                      println('''
+//                      «(subScope.targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf.name» -> nodes
+//                      subScope.maxNewElements «subScope.maxNewElements» = p.maxNewElements «p.maxNewElements»
+//                      ''')
+                        subScope.maxNewElements = p.maxNewElements
+                        return true
+                } else {
+                        return false
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/Z3PolyhedronSolver.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/Z3PolyhedronSolver.xtend
new file mode 100644
index 00000000..3b831433
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/cardinality/Z3PolyhedronSolver.xtend
@@ -0,0 +1,272 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality
+
+import com.microsoft.z3.AlgebraicNum
+import com.microsoft.z3.ArithExpr
+import com.microsoft.z3.Context
+import com.microsoft.z3.Expr
+import com.microsoft.z3.IntNum
+import com.microsoft.z3.Optimize
+import com.microsoft.z3.RatNum
+import com.microsoft.z3.Status
+import com.microsoft.z3.Symbol
+import java.math.BigDecimal
+import java.math.MathContext
+import java.math.RoundingMode
+import java.util.Map
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+class Z3PolyhedronSolver implements PolyhedronSolver {
+        val boolean lpRelaxation
+        val double timeoutSeconds
+
+        @FinalFieldsConstructor
+        new() {
+        }
+
+        new() {
+                this(false, -1)
+        }
+
+        override createSaturationOperator(Polyhedron polyhedron) {
+                new DisposingZ3SaturationOperator(this, polyhedron)
+        }
+
+        def createPersistentSaturationOperator(Polyhedron polyhedron) {
+                new Z3SaturationOperator(polyhedron, lpRelaxation, timeoutSeconds)
+        }
+}
+
+@FinalFieldsConstructor
+class DisposingZ3SaturationOperator implements PolyhedronSaturationOperator {
+        val Z3PolyhedronSolver solver
+        @Accessors val Polyhedron polyhedron
+
+        override saturate() {
+                val persistentOperator = solver.createPersistentSaturationOperator(polyhedron)
+                try {
+                        persistentOperator.saturate
+                } finally {
+                        persistentOperator.close
+                }
+        }
+
+        override close() throws Exception {
+                // Nothing to close.
+        }
+}
+
+class Z3SaturationOperator extends AbstractPolyhedronSaturationOperator {
+        static val INFINITY_SYMBOL_NAME = "oo"
+        static val MULT_SYMBOL_NAME = "*"
+        static val TIMEOUT_SYMBOL_NAME = "timeout"
+        static val INTEGER_PRECISION = new BigDecimal(Integer.MAX_VALUE).precision
+        static val ROUND_DOWN = new MathContext(INTEGER_PRECISION, RoundingMode.FLOOR)
+        static val ROUND_UP = new MathContext(INTEGER_PRECISION, RoundingMode.CEILING)
+        // The interval isolating the number is smaller than 1/10^precision. 
+        static val ALGEBRAIC_NUMBER_ROUNDING = 0
+
+        extension val Context context
+        val Symbol infinitySymbol
+        val Symbol multSymbol
+        val Map<Dimension, ArithExpr> variables
+        val int timeoutMilliseconds
+
+        new(Polyhedron polyhedron, boolean lpRelaxation, double timeoutSeconds) {
+                super(polyhedron)
+                context = new Context
+                infinitySymbol = context.mkSymbol(INFINITY_SYMBOL_NAME)
+                multSymbol = context.mkSymbol(MULT_SYMBOL_NAME)
+                variables = polyhedron.dimensions.toInvertedMap [ dimension |
+                        val name = dimension.name
+                        if (lpRelaxation) {
+                                mkRealConst(name)
+                        } else {
+                                mkIntConst(name)
+                        }
+                ]
+                timeoutMilliseconds = Math.ceil(timeoutSeconds * 1000) as int
+        }
+
+        override doSaturate() {
+                val status = executeSolver()
+                convertStatusToSaturationResult(status)
+        }
+
+        private def convertStatusToSaturationResult(Status status) {
+                switch (status) {
+                        case SATISFIABLE:
+                                PolyhedronSaturationResult.SATURATED
+                        case UNSATISFIABLE:
+                                PolyhedronSaturationResult.EMPTY
+                        case UNKNOWN:
+                                PolyhedronSaturationResult.UNKNOWN
+                        default:
+                                throw new IllegalArgumentException("Unknown Status: " + status)
+                }
+        }
+
+        private def executeSolver() {
+                for (expressionToSaturate : polyhedron.expressionsToSaturate) {
+                        val expr = expressionToSaturate.toExpr
+                        val lowerResult = saturateLowerBound(expr, expressionToSaturate)
+                        if (lowerResult != Status.SATISFIABLE) {
+                                return lowerResult
+                        }
+                        val upperResult = saturateUpperBound(expr, expressionToSaturate)
+                        if (upperResult != Status.SATISFIABLE) {
+                                return upperResult
+                        }
+                }
+                Status.SATISFIABLE
+        }
+
+        private def saturateLowerBound(ArithExpr expr, LinearBoundedExpression expressionToSaturate) {
+                val optimize = prepareOptimize
+                val handle = optimize.MkMinimize(expr)
+                val status = optimize.Check()
+                if (status == Status.SATISFIABLE) {
+                        val value = switch (resultExpr : handle.lower) {
+                                IntNum:
+                                        resultExpr.getInt()
+                                RatNum:
+                                        ceil(resultExpr)
+                                AlgebraicNum:
+                                        ceil(resultExpr.toUpper(ALGEBRAIC_NUMBER_ROUNDING))
+                                default:
+                                        if (isNegativeInfinity(resultExpr)) {
+                                                null
+                                        } else {
+                                                throw new IllegalArgumentException("Integer result expected, got: " + resultExpr)
+                                        }
+                        }
+                        expressionToSaturate.lowerBound = value
+                }
+                status
+        }
+
+        private def floor(RatNum ratNum) {
+                val numerator = new BigDecimal(ratNum.numerator.bigInteger)
+                val denominator = new BigDecimal(ratNum.denominator.bigInteger)
+                numerator.divide(denominator, ROUND_DOWN).setScale(0, RoundingMode.FLOOR).intValue
+        }
+
+        private def saturateUpperBound(ArithExpr expr, LinearBoundedExpression expressionToSaturate) {
+                val optimize = prepareOptimize
+                val handle = optimize.MkMaximize(expr)
+                val status = optimize.Check()
+                if (status == Status.SATISFIABLE) {
+                        val value = switch (resultExpr : handle.upper) {
+                                IntNum:
+                                        resultExpr.getInt()
+                                RatNum:
+                                        floor(resultExpr)
+                                AlgebraicNum:
+                                        floor(resultExpr.toLower(ALGEBRAIC_NUMBER_ROUNDING))
+                                default:
+                                        if (isPositiveInfinity(resultExpr)) {
+                                                null
+                                        } else {
+                                                throw new IllegalArgumentException("Integer result expected, got: " + resultExpr)
+                                        }
+                        }
+                        expressionToSaturate.upperBound = value
+                }
+                status
+        }
+
+        private def ceil(RatNum ratNum) {
+                val numerator = new BigDecimal(ratNum.numerator.bigInteger)
+                val denominator = new BigDecimal(ratNum.denominator.bigInteger)
+                numerator.divide(denominator, ROUND_UP).setScale(0, RoundingMode.CEILING).intValue
+        }
+
+        private def isPositiveInfinity(Expr expr) {
+                expr.app && expr.getFuncDecl.name == infinitySymbol
+        }
+
+        private def isNegativeInfinity(Expr expr) {
+                // Negative infinity is represented as (* (- 1) oo)
+                if (!expr.app || expr.getFuncDecl.name != multSymbol || expr.numArgs != 2) {
+                        return false
+                }
+                isPositiveInfinity(expr.args.get(1))
+        }
+
+        private def prepareOptimize() {
+                val optimize = mkOptimize()
+                if (timeoutMilliseconds >= 0) {
+                        val params = mkParams()
+                        // We cannot turn TIMEOUT_SYMBOL_NAME into a Symbol in the constructor,
+                        // because there is no add(Symbol, int) overload.
+                        params.add(TIMEOUT_SYMBOL_NAME, timeoutMilliseconds)
+                        optimize.parameters = params
+                }
+                assertConstraints(optimize)
+                optimize
+        }
+
+        private def assertConstraints(Optimize it) {
+                for (pair : variables.entrySet) {
+                        assertBounds(pair.value, pair.key)
+                }
+                for (constraint : nonTrivialConstraints) {
+                        val expr = createLinearCombination(constraint.coefficients)
+                        assertBounds(expr, constraint)
+                }
+        }
+
+        private def assertBounds(Optimize it, ArithExpr expression, LinearBoundedExpression bounds) {
+                val lowerBound = bounds.lowerBound
+                val upperBound = bounds.upperBound
+                if (lowerBound == upperBound) {
+                        if (lowerBound === null) {
+                                return
+                        }
+                        Assert(mkEq(expression, mkInt(lowerBound)))
+                } else {
+                        if (lowerBound !== null) {
+                                Assert(mkGe(expression, mkInt(lowerBound)))
+                        }
+                        if (upperBound !== null) {
+                                Assert(mkLe(expression, mkInt(upperBound)))
+                        }
+                }
+        }
+
+        private def toExpr(LinearBoundedExpression linearBoundedExpression) {
+                switch (linearBoundedExpression) {
+                        Dimension: variables.get(linearBoundedExpression)
+                        LinearConstraint: createLinearCombination(linearBoundedExpression.coefficients)
+                        default: throw new IllegalArgumentException("Unknown linear bounded expression:" + linearBoundedExpression)
+                }
+        }
+
+        private def createLinearCombination(Map<Dimension, Integer> coefficients) {
+                val size = coefficients.size
+                if (size == 0) {
+                        return mkInt(0)
+                }
+                val array = newArrayOfSize(size)
+                var int i = 0
+                for (pair : coefficients.entrySet) {
+                        val variable = variables.get(pair.key)
+                        if (variable === null) {
+                                throw new IllegalArgumentException("Unknown dimension: " + pair.key.name)
+                        }
+                        val coefficient = pair.value
+                        val term = if (coefficient == 1) {
+                                        variable
+                                } else {
+                                        mkMul(mkInt(coefficient), variable)
+                                }
+                        array.set(i, term)
+                        i++
+                }
+                mkAdd(array)
+        }
+
+        override close() throws Exception {
+                context.close()
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/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 677170b8..edf92343 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
@@ -1,7 +1,6 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

 

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

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

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

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

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

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

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

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

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

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

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

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

+import java.util.Collection

 import java.util.HashMap

 import java.util.Map

 import org.eclipse.emf.ecore.EAttribute

 import org.eclipse.emf.ecore.EReference

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

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

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

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

+import org.eclipse.xtend2.lib.StringConcatenationClient

 

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

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

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

 

 @Data class PatternGeneratorResult {

         CharSequence patternText

@@ -35,22 +39,32 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint
         HashMap<PConstraint,String> constraint2CurrentPreconditionName

 }

 

+interface UnitPropagationPatternGenerator {

+        def Map<Relation, String> getMustPatterns()

+        

+        def Map<Relation, String> getMustNotPatterns()

+        

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

+}

+

 class PatternGenerator {

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

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

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

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

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

+                this)

+        @Accessors(PUBLIC_GETTER) val RelationDefinitionIndexer relationDefinitionIndexer = new RelationDefinitionIndexer(

+                this)

         @Accessors(PUBLIC_GETTER) val ContainmentIndexer containmentIndexer = new ContainmentIndexer(this)

         @Accessors(PUBLIC_GETTER) val InvalidIndexer invalidIndexer = new InvalidIndexer(this)

-        @Accessors(PUBLIC_GETTER) val UnfinishedIndexer unfinishedIndexer = new UnfinishedIndexer(this)

+        @Accessors(PUBLIC_GETTER) val UnfinishedIndexer unfinishedIndexer

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

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

         @Accessors(PUBLIC_GETTER) val UnitPropagationPreconditionGenerator unitPropagationPreconditionGenerator = new UnitPropagationPreconditionGenerator(this)

         

-        public new(TypeInferenceMethod typeInferenceMethod) {

+        new(TypeInferenceMethod typeInferenceMethod, ScopePropagatorStrategy scopePropagatorStrategy) {

                 if(typeInferenceMethod == TypeInferenceMethod.Generic) {

                         this.typeIndexer = new GenericTypeIndexer(this)

                         this.typeRefinementGenerator = new GenericTypeRefinementGenerator(this)

-                } else if(typeInferenceMethod == TypeInferenceMethod.PreliminaryAnalysis) {

+                } else if (typeInferenceMethod == TypeInferenceMethod.PreliminaryAnalysis) {

                         this.typeIndexer = new TypeIndexerWithPreliminaryTypeAnalysis(this)

                         this.typeRefinementGenerator = new TypeRefinementWithPreliminaryTypeAnalysis(this)

                 } else {

@@ -58,110 +72,102 @@ 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 PatternGeneratorResult transformBaseProperties(

+

+        def transformBaseProperties(

                 LogicProblem problem,

                 PartialInterpretation emptySolution,

-                Map<String,PQuery> fqn2PQuery,

-                TypeAnalysisResult typeAnalysisResult

+                Map<String, PQuery> fqn2PQuery,

+                TypeAnalysisResult typeAnalysisResult,

+                RelationConstraints constraints,

+                Collection<LinearTypeConstraintHint> hints,

+                Collection<UnitPropagationPatternGenerator> unitPropagationPatternGenerators

         ) {

                 val first = 

                  '''

@@ -199,7 +205,7 @@ class PatternGenerator {
                         

                         private pattern elementCloseWorld(element:DefinedElement) {

                                 PartialInterpretation.openWorldElements(i,element);

-                            PartialInterpretation.maxNewElements(i,0);

+                                PartialInterpretation.maxNewElements(i,0);

                         } or {

                                 Scope.targetTypeInterpretation(scope,interpretation);

                                 PartialTypeInterpratation.elements(interpretation,element);

@@ -288,7 +294,9 @@ class PatternGenerator {
                         //////////

                         // 1.1.1 Required Patterns by TypeIndexer

                         //////////

+

                         «typeIndexer.requiredQueries»

+                        

                         //////////

                         // 1.1.2 primitive Type Indexers

                         //////////

@@ -306,6 +314,7 @@ class PatternGenerator {
                         // > StringElement.value(variableName,value)

                         // Whether a value is set is defined by:

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

+                        

                         //////////

                         // 1.1.3 domain-specific Type Indexers

                         //////////

@@ -314,7 +323,7 @@ class PatternGenerator {
                         //////////

                         // 1.2 Relation Declaration Indexers

                         //////////

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

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

                         

                         //////////

                         // 1.3 Relation Definition Indexers

@@ -338,7 +347,7 @@ class PatternGenerator {
                         //////////

                         // 3.1 Unfinishedness Measured by Multiplicity

                         //////////

-                        «unfinishedIndexer.generateUnfinishedMultiplicityQueries(problem,fqn2PQuery)»

+                        «unfinishedIndexer.generateUnfinishedMultiplicityQueries(constraints.multiplicityConstraints,fqn2PQuery)»

                         

                         //////////

                         // 3.2 Unfinishedness Measured by WF Queries

@@ -360,14 +369,24 @@ class PatternGenerator {
                         //////////

                         // 4.3 Relation refinement

                         //////////

-                        «relationRefinementGenerator.generateRefineReference(problem)»

+                        «relationRefinementGenerator.generateRefineReference(problem, unitPropagationPatternGenerators)»

+                        

+                        //////////

+                        // 5 Hints

+                        //////////

+                        «FOR hint : hints»

+                                «hint.getAdditionalPatterns(this, fqn2PQuery)»

+                        «ENDFOR»

+                        «FOR generator : unitPropagationPatternGenerators»

+                                «generator.getAdditionalPatterns(this, fqn2PQuery)»

+                        «ENDFOR»

                         

                         //////////

-                        // 5 Unit Propagations

+                        // 6 Unit Propagations

                         //////////

                         '''

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

-                        val second = up.definitions

-                        return new PatternGeneratorResult(first+second,up.constraint2MustPreconditionName,up.constraint2CurrentPreconditionName)

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

+                val second = up.definitions

+                return new PatternGeneratorResult(first+second,up.constraint2MustPreconditionName,up.constraint2CurrentPreconditionName)

         }

 }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
index f3de4ccc..2e786286 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
@@ -1,79 +1,108 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

 

+import com.google.common.collect.ImmutableSet

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.util.ParseUtil

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

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

+import java.util.Collection

+import java.util.HashMap

 import java.util.Map

+import java.util.Set

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

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

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

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

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

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

 

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

-import java.util.Collection

-import java.util.Set

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

-import java.util.HashMap

 

 @Data class GeneratedPatterns {

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

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

-        public Map<Relation,  Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> unfinishedContainmentMulticiplicityQueries

-        public Map<Relation,  Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> unfinishedNonContainmentMulticiplicityQueries

-        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<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>  mustUnitPropagationPreconditionPatterns

-        public Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>  currentUnitPropagationPreconditionPatterns

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

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

+        public Map<RelationMultiplicityConstraint, UnifinishedMultiplicityQueries> multiplicityConstraintQueries

+        public IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> hasElementInContainmentQuery

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

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

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

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

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

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

+        public Map<RelationDefinition, ModalPatternQueries> modalRelationQueries

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

 }

 

+@Data

+class ModalPatternQueries {

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

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

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

+}

+

+@Data

+class UnifinishedMultiplicityQueries {

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

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

+

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

+                val builder = ImmutableSet.builder

+                if (existingMultiplicityQuery !== null) {

+                        builder.add(existingMultiplicityQuery)

+                }

+                if (existingInverseMultiplicityQuery !== null) {

+                        builder.add(existingInverseMultiplicityQuery)

+                }

+                builder.build

+        }

+}

+

 class PatternProvider {

-        

         val TypeAnalysis typeAnalysis = new TypeAnalysis

-        

-        public def generateQueries(

-                LogicProblem problem,

-                PartialInterpretation emptySolution,

-                ModelGenerationStatistics statistics,

-                Set<PQuery> existingQueries,

-                ReasonerWorkspace workspace,

-                TypeInferenceMethod typeInferenceMethod,

-                boolean writeToFile)

-        {

+

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

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

+                ScopePropagatorStrategy scopePropagatorStrategy, RelationConstraints relationConstraints,

+                Collection<LinearTypeConstraintHint> hints,

+                Collection<UnitPropagationPatternGenerator> unitPropagationPatternGenerators, boolean writeToFile) {

                 val fqn2Query = existingQueries.toMap[it.fullyQualifiedName]

-                val PatternGenerator patternGenerator = new PatternGenerator(typeInferenceMethod)

-                val typeAnalysisResult = if(patternGenerator.requiresTypeAnalysis) {

-                        val startTime = System.nanoTime

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

-                        val typeAnalysisTime = System.nanoTime - startTime

-                        statistics.PreliminaryTypeAnalisisTime = typeAnalysisTime

-                        result

-                } else {

-                        null

-                }

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

-                val baseIndexerFile = patternGeneratorResult.patternText

-                val mustUnitPropagationTrace = patternGeneratorResult.constraint2MustPreconditionName

-                val currentUnitPropagationTrace = patternGeneratorResult.constraint2CurrentPreconditionName

-                if(writeToFile) {

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

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

+                val typeAnalysisResult = if (patternGenerator.requiresTypeAnalysis) {

+                                val startTime = System.nanoTime

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

+                                val typeAnalysisTime = System.nanoTime - startTime

+                                statistics.preliminaryTypeAnalisisTime = typeAnalysisTime

+                                result

+                        } else {

+                                null

+                        }

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

+                        typeAnalysisResult, relationConstraints, hints, unitPropagationPatternGenerators)

+                if (writeToFile) {

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

                 }

                 val ParseUtil parseUtil = new ParseUtil

-                val generatedQueries = parseUtil.parse(baseIndexerFile)

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

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

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

+                        patternGeneratorResult.constraint2MustPreconditionName,

+                        patternGeneratorResult.constraint2CurrentPreconditionName, relationConstraints,

+                        unitPropagationPatternGenerators, generatedQueries)

                 return runtimeQueries

         }

-        

+

         private def GeneratedPatterns calclulateRuntimeQueries(

                 PatternGenerator patternGenerator,

                 LogicProblem problem,

@@ -81,51 +110,62 @@ class PatternProvider {
                 TypeAnalysisResult typeAnalysisResult,

                 HashMap<PConstraint, String> mustUnitPropagationTrace,

                 HashMap<PConstraint, String> currentUnitPropagationTrace,

+                RelationConstraints relationConstraints,

+                Collection<UnitPropagationPatternGenerator> unitPropagationPatternGenerators,

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

         ) {

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

-                        invalidWFQueries = patternGenerator.invalidIndexer.getInvalidateByWfQueryNames(problem).mapValues[it.lookup(queries)]

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

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

-                        

-                val unfinishedMultiplicities = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(problem)

-                val unfinishedContainmentMultiplicities = new HashMap

-                val unfinishedNonContainmentMultiplicities = new HashMap

-                for(entry : unfinishedMultiplicities.entrySet) {

-                        val relation = entry.key

-                        val name = entry.value.key

-                        val amount = entry.value.value

-                        val query = name.lookup(queries)

-                        if(problem.containmentHierarchies.head.containmentRelations.contains(relation)) {

-                                unfinishedContainmentMultiplicities.put(relation,query->amount)

-                        } else {

-                                unfinishedNonContainmentMultiplicities.put(relation,query->amount)

-                        }

-                }

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

-//                      unfinishedMultiplicityQueries = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(problem).mapValues[it.lookup(queries)]

-//                      

-                        

-                val Map<ObjectCreationPrecondition,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>

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

-                val Map<? extends Type,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>

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

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

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

-                val Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> 

-                        mustUnitPropagationPreconditionPatterns = mustUnitPropagationTrace.mapValues[it.lookup(queries)]

-                val Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> 

-                        currentUnitPropagationPreconditionPatterns = currentUnitPropagationTrace.mapValues[it.lookup(queries)]

+                val Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidWFQueries = patternGenerator.

+                        invalidIndexer.getInvalidateByWfQueryNames(problem).mapValues[it.lookup(queries)]

+                val Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWFQueries = patternGenerator.

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

+

+                val unfinishedMultiplicities = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(

+                        relationConstraints.multiplicityConstraints)

+                val multiplicityConstraintQueries = unfinishedMultiplicities.mapValues [

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

+                                existingInverseMultiplicityQueryName?.lookup(queries))

+                ]

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

+                        queries)

+

+                val Map<ObjectCreationPrecondition, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineObjectsQueries = patternGenerator.

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

+                                it.lookup(queries)

+                        ]

+                val Map<? extends Type, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineTypeQueries = patternGenerator.

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

+                                it.lookup(queries)

+                        ]

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

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

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

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

+                val Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> mustUnitPropagationPreconditionPatterns = mustUnitPropagationTrace.

+                        mapValues[it.lookup(queries)]

+                val Map<PConstraint, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> currentUnitPropagationPreconditionPatterns = currentUnitPropagationTrace.

+                        mapValues[it.lookup(queries)]

+

+                val modalRelationQueries = problem.relations.filter(RelationDefinition).toMap([it], [ relationDefinition |

+                        val indexer = patternGenerator.relationDefinitionIndexer

+                        new ModalPatternQueries(

+                                indexer.relationDefinitionName(relationDefinition, Modality.MAY).lookup(queries),

+                                indexer.relationDefinitionName(relationDefinition, Modality.MUST).lookup(queries),

+                                indexer.relationDefinitionName(relationDefinition, Modality.CURRENT).lookup(queries)

+                        )

+                ])

+

                 return new GeneratedPatterns(

                         invalidWFQueries,

                         unfinishedWFQueries,

-                        unfinishedContainmentMultiplicities,

-                        unfinishedNonContainmentMultiplicities,

+                        multiplicityConstraintQueries,

+                        hasElementInContainmentQuery,

                         refineObjectsQueries,

                         refineTypeQueries,

                         refineRelationQueries,

+                        mustRelationPropagationQueries,

                         mustUnitPropagationPreconditionPatterns,

                         currentUnitPropagationPreconditionPatterns,

+                        modalRelationQueries,

                         queries.values

                 )

         }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
index cef707c5..23ba3cad 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
@@ -1,10 +1,13 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

 

+import com.google.common.collect.ImmutableMap

+import com.google.common.collect.ImmutableSet

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

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

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

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

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

+import java.util.Collection

 import java.util.HashMap

 import java.util.List

 import java.util.Map

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

 class RelationDeclarationIndexer {

         val PatternGenerator base;

-        

+

         new(PatternGenerator base) {

                 this.base = base

         }

-        

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

+

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

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

                 val upperMultiplicities = new HashMap

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

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

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

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

                 ]

-                

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

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

+

                 return '''

-                «FOR relation : relations»

-                        «IF base.isDerived(relation)»

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

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

-                        «ELSE»

-                                «generateMustRelation(problem,relation)»

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

-                        «ENDIF»

-                «ENDFOR»

+                        «FOR relation : relations»

+                                «IF base.isDerived(relation)»

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

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

+                                «ELSE»

+                                        «generateMustRelation(problem, relation)»

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

+                                «ENDIF»

+                        «ENDFOR»

                 '''

         }

-        

+

         def private patternName(RelationDeclaration r, Modality modality) {

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

         }

-        

-        public def referRelation(

-                RelationDeclaration referred,

-                String sourceVariable,

-                String targetVariable,

-                Modality modality)

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

-        

+

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

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

+

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

                 /**

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

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

                 }

         '''

+

         def generateMayRelation(LogicProblem problem, RelationDeclaration relation,

-                Map<Relation, Integer> upperMultiplicities,

-                List<Relation> containments,

-                HashMap<Relation, Relation> inverseRelations,

-                Map<String,PQuery> fqn2PQuery)

-        {

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

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

+                Map<String, PQuery> fqn2PQuery) {

                 return '''

-                /**

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

-                 */

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

-                        problem:LogicProblem, interpretation:PartialInterpretation,

-                        source: DefinedElement, target:DefinedElement)

-                {

-                        find interpretation(problem,interpretation);

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

-                        find mayExist(problem, interpretation, source);

-                        find mayExist(problem, interpretation, target);

-                        // Type consistency

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

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

-                        «IF upperMultiplicities.containsKey(relation)»

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

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

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

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

-                        «ENDIF»

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

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

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

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

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

-                        «ENDIF»

-                        «IF containments.contains(relation)»

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

-                                // 1. Multiple parents

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

-                                // 2. Circle in the containment hierarchy

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

-                        «ENDIF»

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

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

-                                // 1. Multiple parents

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

-                                // 2. Circle in the containment hierarchy

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

-                        «ENDIF»

-                } or {

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

-                }

-        '''

+                        /**

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

+                         */

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

+                                problem:LogicProblem, interpretation:PartialInterpretation,

+                                source: DefinedElement, target:DefinedElement)

+                        {

+                                find interpretation(problem,interpretation);

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

+                                find mayExist(problem, interpretation, source);

+                                find mayExist(problem, interpretation, target);

+                                // Type consistency

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

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

+                                «IF upperMultiplicities.containsKey(relation)»

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

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

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

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

+                                «ENDIF»

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

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

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

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

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

+                                «ENDIF»

+                                «IF containments.contains(relation)»

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

+                                        // 1. Multiple parents

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

+                                        // 2. Circle in the containment hierarchy

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

+                                «ENDIF»

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

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

+                                        // 1. Multiple parents

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

+                                        // 2. Circle in the containment hierarchy

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

+                                «ENDIF»

+                                «IF !mustNotRelations.empty»

+                                        // ![] unit propagation relations

+                                        «FOR mustNotRelation : mustNotRelations»

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

+                                        «ENDFOR»

+                                «ENDIF»

+                        } or {

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

+                        }

+                '''

         }

-        

+

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

                 /**

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

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

                  }

         '''

+

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

                 /**

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

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

                  }

         '''

-}
\ No newline at end of file
+}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
index 37950834..338a9af2 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
@@ -7,10 +7,10 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
 import java.util.Map

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

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

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

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

 

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

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

 

 class RelationDefinitionIndexer {

         public val PatternGenerator base;

@@ -60,7 +60,7 @@ class RelationDefinitionIndexer {
                 ]

         }

         

-        private def relationDefinitionName(RelationDefinition relation, Modality modality)

+        def String relationDefinitionName(RelationDefinition relation, Modality modality)

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

         

         def canonizeName(PVariable v) {

@@ -102,6 +102,4 @@ class RelationDefinitionIndexer {
         def referPattern(PQuery p, String[] variables, Modality modality, boolean positive, boolean transitive) '''

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

         '''

-        

-        

 }
\ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend
index f9e9baea..6f5f2402 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend
@@ -1,85 +1,93 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

 

+import com.google.common.collect.ImmutableList

+import com.google.common.collect.ImmutableMap

+import com.google.common.collect.ImmutableSet

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

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

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

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

+import java.util.Collection

 import java.util.LinkedList

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

+import java.util.Map

+import java.util.Set

+import org.eclipse.xtend2.lib.StringConcatenationClient

 

 class RelationRefinementGenerator {

         PatternGenerator base;

-        public new(PatternGenerator base) {

+

+        new(PatternGenerator base) {

                 this.base = base

         }

-        

-        def CharSequence generateRefineReference(LogicProblem p) {

-                return '''

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

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

-                        problem:LogicProblem, interpretation:PartialInterpretation,

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

-                        from: DefinedElement, to: DefinedElement)

-                {

-                        find interpretation(problem,interpretation);

-                        PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);

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

-                        «IF relationRefinement.value != null»

-                                PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation);

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

-                        «ENDIF»

-                        find mustExist(problem, interpretation, from);

-                        find mustExist(problem, interpretation, to);

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

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

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

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

-                }

-                «ENDFOR»

+

+        def CharSequence generateRefineReference(LogicProblem p,

+                Collection<UnitPropagationPatternGenerator> unitPropagationPatternGenerators) {

+                val mustRelations = getMustRelations(unitPropagationPatternGenerators)

+

+                '''

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

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

+                                        problem:LogicProblem, interpretation:PartialInterpretation,

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

+                                        from: DefinedElement, to: DefinedElement)

+                                {

+                                        find interpretation(problem,interpretation);

+                                        PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);

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

+                                        «IF relationRefinement.value !== null»

+                                                PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation);

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

+                                        «ENDIF»

+                                        find mustExist(problem, interpretation, from);

+                                        find mustExist(problem, interpretation, to);

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

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

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

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

+                                }

+                                

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

+                                        pattern «mustPropagationQueryName(relationRefinement.key)»(

+                                                problem:LogicProblem, interpretation:PartialInterpretation,

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

+                                                from: DefinedElement, to: DefinedElement)

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

+                                                {

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

+                                                        «body»

+                                                }

+                                        «ENDFOR»

+                                «ENDIF»

+                        «ENDFOR»

                 '''

         }

-        

+

         def String relationRefinementQueryName(RelationDeclaration relation, Relation inverseRelation) {

-                '''«IF inverseRelation != null

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

-                        ELSE

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

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

         }

-        

+

+        def String mustPropagationQueryName(RelationDeclaration relation) {

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

+        }

+

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

-                String inverseInterpretationName, String sourceName, String targetName)

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

-        

+                String inverseInterpretationName, String sourceName,

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

+

         def getRefineRelationQueries(LogicProblem p) {

-//              val containmentRelations = p.containmentHierarchies.map[containmentRelations].flatten.toSet

-//              p.relations.filter(RelationDeclaration).filter[!containmentRelations.contains(it)].toInvertedMap['''refineRelation_«base.canonizeName(it.name)»''']

-                /*

-                val res = new LinkedHashMap

-                for(relation: getRelationRefinements(p)) {

-                        if(inverseRelations.containsKey(relation)) {

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

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

-                        } else {

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

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

-                        }

-                }

-                return res*/

-                

-                getRelationRefinements(p).toInvertedMap[relationRefinementQueryName(it.key,it.value)]

+                getRelationRefinements(p).toInvertedMap[relationRefinementQueryName(it.key, it.value)]

         }

-        

 

         def getRelationRefinements(LogicProblem p) {

                 val inverses = base.getInverseRelations(p)

                 val containments = base.getContainments(p)

                 val list = new LinkedList

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

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

-                                if(inverses.containsKey(relation)) {

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

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

+                                if (inverses.containsKey(relation)) {

                                         val inverse = inverses.get(relation)

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

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

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

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

                                                         list += (relation -> inverse)

                                                 }

                                         }

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

                 return list

         }

-}
\ No newline at end of file
+

+        def getMustPropagationQueries(LogicProblem p,

+                Collection<UnitPropagationPatternGenerator> unitPropagationPatternGenerators) {

+                val refinements = getRelationRefinements(p)

+                val mustRelations = getMustRelations(unitPropagationPatternGenerators)

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

+                        mustPropagationQueryName(key)

+                ]

+        }

+

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

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

+                        ImmutableSet.copyOf(map[value])

+                ])

+        }

+

+        private def isMustPropagationQueryNeeded(Relation relation, Relation inverseRelation,

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

+                val mustSet = mustRelations.get(relation)

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

+                        return true

+                }

+                if (inverseRelation !== null) {

+                        val inverseMustSet = mustRelations.get(inverseRelation)

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

+                                return true

+                        }

+                }

+                false

+        }

+

+        private def getMustPropagationBodies(Relation relation, Relation inverseRelation,

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

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

+                val mustSet = mustRelations.get(relation)

+                if (mustSet !== null) {

+                        for (refinementQuery : mustSet) {

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

+                        }

+                }

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

+                        val inverseMustSet = mustRelations.get(inverseRelation)

+                        if (inverseMustSet !== null) {

+                                for (refinementQuery : inverseMustSet) {

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

+                                }

+                        }

+                }

+                builder.build

+        }

+}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend
index 41eb75a8..e4e2aa30 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend
@@ -1,54 +1,126 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns

 

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

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

-import org.eclipse.emf.ecore.EClass

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 import java.math.BigDecimal

+import org.eclipse.emf.ecore.EClass

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

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

 

+@FinalFieldsConstructor

 abstract class TypeIndexer {

-        public def CharSequence getRequiredQueries()

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

         }

-        public def CharSequence referPrimitiveFilled(String variableName, boolean isFilled) {

+

+        def CharSequence referPrimitiveFilled(String variableName, boolean isFilled) {

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

         }

-}
\ No newline at end of file
+}

+

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend
index d3af0426..0393b803 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend
@@ -4,113 +4,51 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem

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

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

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

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

-import org.eclipse.emf.ecore.EClass

 

-class TypeIndexerWithPreliminaryTypeAnalysis extends TypeIndexer{

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

 

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

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

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

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

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

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

+import java.util.LinkedHashMap

+import java.util.List

 import java.util.Map

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

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

 

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

-import java.util.LinkedHashMap

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

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

+

+@Data

+class UnifinishedMultiplicityQueryNames {

+        val String existingMultiplicityQueryName

+        val String existingInverseMultiplicityQueryName

+}

 

 class UnfinishedIndexer {

         val PatternGenerator base

-        

-        new(PatternGenerator patternGenerator) {

+        val boolean indexUpperMultiplicities

+

+        new(PatternGenerator patternGenerator, boolean indexUpperMultiplicities) {

                 this.base = patternGenerator

+                this.indexUpperMultiplicities = indexUpperMultiplicities

         }

-        

-        def generateUnfinishedWfQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) {

+

+        def generateUnfinishedWfQueries(LogicProblem problem, Map<String, PQuery> fqn2PQuery) {

                 val wfQueries = base.wfQueries(problem)

                 '''

-                «FOR wfQuery: wfQueries»

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

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

-                        {

-                                «base.relationDefinitionIndexer.referPattern(

+                        «FOR wfQuery : wfQueries»

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

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

+                                {

+                                        «base.relationDefinitionIndexer.referPattern(

                                         wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery),

                                         wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters.map['''var_«it.name»'''],

                                         Modality.CURRENT,

                                         true,false)»

-                        }

-                «ENDFOR»

+                                }

+                        «ENDFOR»

                 '''

         }

+

         def getUnfinishedWFQueryNames(LogicProblem problem) {

                 val wfQueries = base.wfQueries(problem)

                 val map = new LinkedHashMap

-                for(wfQuery : wfQueries) {

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

+                for (wfQuery : wfQueries) {

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

                 }

                 return map

         }

-        def generateUnfinishedMultiplicityQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) {

-                val lowerMultiplicities = base.lowerMultiplicities(problem)

-                return '''

-                «FOR lowerMultiplicity : lowerMultiplicities»

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

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

-«««                          numberOfExistingReferences < «lowerMultiplicity.lower»;

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

-                        }

+

+        def generateUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints,

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

+                «FOR constraint : constraints»

+                        «IF constraint.shouldIndexExistingMultiplicites(indexUpperMultiplicities)»

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

+                                        find interpretation(problem,interpretation);

+                                        find mustExist(problem,interpretation,object);

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

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

+                                        «IF constraint.shouldIndexRepairMultiplcities(indexUpperMultiplicities)»

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

+                                        «ENDIF»

+                                }

+                        «ENDIF»

+                        

+                        «IF constraint.shouldIndexRepairMatches(indexUpperMultiplicities)»

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

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

+                                                «repairMatchFallback(constraint, fqn2PQuery)»

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

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

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

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

+                                        «ELSE»

+                                                «repairMatchFallback(constraint, fqn2PQuery)»

+                                        «ENDIF»

+                                }

+                        «ENDIF»

+                        

+                        «IF constraint.shouldIndexInverseMultiplicites(indexUpperMultiplicities)»

+                                private pattern «existingInverseMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, numberOfExistingReferences:java Integer, numberOfRepairMatches: java Integer) {

+                                        find interpretation(problem,interpretation);

+                                        find mustExist(problem,interpretation,object);

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

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

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

+                                }

+                        «ENDIF»

                 «ENDFOR»

-                '''

+        '''

+

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

+                find interpretation(problem,interpretation);

+                find mustExist(problem,interpretation,source);

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

+                find mustExist(problem,interpretation,target);

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

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

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

+        '''

+

+        def String existingMultiplicityName(

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

+

+        def String existingInverseMultiplicityName(

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

+

+        private def String repairMatchName(

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

+

+        def getUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints) {

+                constraints.toInvertedMap [ constraint |

+                        new UnifinishedMultiplicityQueryNames(

+                                if (constraint.shouldIndexExistingMultiplicites(indexUpperMultiplicities)) {

+                                        existingMultiplicityName(constraint)

+                                } else {

+                                        null

+                                },

+                                if (constraint.shouldIndexInverseMultiplicites(indexUpperMultiplicities)) {

+                                        existingInverseMultiplicityName(constraint)

+                                } else {

+                                        null

+                                }

+                        )

+                ]

         }

-        def String unfinishedMultiplicityName(LowerMultiplicityAssertion lowerMultiplicityAssertion) 

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

-        

-        //def public referUnfinishedMultiplicityQuery(LowerMultiplicityAssertion lowerMultiplicityAssertion)

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

-        

-        def getFirstParamTypeOfRelation(LowerMultiplicityAssertion lowerMultiplicityAssertion) {

-                val parameters = lowerMultiplicityAssertion.relation.parameters

-                if(parameters.size == 2) {

-                        val firstParam = parameters.get(0)

-                        if(firstParam instanceof ComplexTypeReference) {

-                                return firstParam.referred

-                        }

-                }

+

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

+                constrainsUnfinished || (indexUpperMultiplicities && constrainsRemainingContents)

         }

-        

-        def getUnfinishedMultiplicityQueries(LogicProblem problem) {

-                val lowerMultiplicities = base.lowerMultiplicities(problem)

-                val map = new LinkedHashMap

-                for(lowerMultiplicity : lowerMultiplicities) {

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

-                }

-                return map

+

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

+                shouldIndexExistingMultiplicites(indexUpperMultiplicities) && constrainsUnrepairable

+        }

+

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

+                indexUpperMultiplicities && constrainsRemainingInverse

+        }

+

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

+                shouldIndexRepairMultiplcities(indexUpperMultiplicities) ||

+                        shouldIndexInverseMultiplicites(indexUpperMultiplicities)

         }

 }

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
index e03a8c35..732c135d 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
@@ -2,97 +2,88 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules
 

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

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

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

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

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

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

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

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

 import java.util.ArrayList

 import java.util.HashMap

 import java.util.LinkedList

 import java.util.List

 import java.util.Map

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

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

-import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher

-

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

 

 class GoalConstraintProvider {

-        

-        def public getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns, boolean calculateObjectCost) {

+

+        def getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns, boolean calculateObjectCost) {

+                val objectCosts = if (calculateObjectCost) {

+                                calculateMissingObjectCost(p)

+                        } else {

+                                emptyMap

+                        }

                 val res = new ArrayList()

-                

-                res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false)

-                if(calculateObjectCost) {

-                        val missingObjectCost = calculateMissingObjectCost(p)

-                        res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true,missingObjectCost)

-                } else {

-                        res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true)

+                for (entry : patterns.multiplicityConstraintQueries.entrySet) {

+                        val constraint = entry.key

+                        if (constraint.constrainsUnfinished) {

+                                val queries = entry.value

+                                val targetRelationName = constraint.relation.name

+                                val query = queries.existingMultiplicityQuery

+                                val containment = constraint.containment

+                                val lowerBound = constraint.lowerBound

+                                val cost = objectCosts.getOrDefault(constraint.relation, 1)

+                                res += new MultiplicityGoalConstraintCalculator(

+                                        targetRelationName,

+                                        query,

+                                        containment,

+                                        lowerBound,

+                                        cost

+                                )

+                        }

                 }

                 return res

         }

-        

-        def addAll(ArrayList<MultiplicityGoalConstraintCalculator> res, Map<Relation, Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> queries, boolean containment) {

-                for(multiplicityQuery : queries.entrySet) {

-                        val targetRelationName = multiplicityQuery.key.name

-                        val query = multiplicityQuery.value.key

-                        val minValue = multiplicityQuery.value.value

-                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,1);

-                }

-        }

-        def addAll(

-                ArrayList<MultiplicityGoalConstraintCalculator> res,

-                Map<Relation, Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> queries,

-                boolean containment,

-                Map<Relation, Integer> cost

-        ) {

-                for(multiplicityQuery : queries.entrySet) {

-                        val targetRelationName = multiplicityQuery.key.name

-                        val query = multiplicityQuery.value.key

-                        val minValue = multiplicityQuery.value.value

-                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,multiplicityQuery.key.lookup(cost))

-                }

-        }

-        

-        def calculateMissingObjectCost(LogicProblem p) {

+

+        private def calculateMissingObjectCost(LogicProblem p) {

                 val containments = p.containmentHierarchies.head.containmentRelations

-                val containment2Lower = containments.toInvertedMap[containment | 

+                val containment2Lower = containments.toInvertedMap [ containment |

                         val lower = p.annotations.filter(LowerMultiplicityAssertion).filter[it.relation === containment].head

-                        if(lower !== null) { lower.lower }

-                        else { 0 }

+                        if (lower !== null) {

+                                lower.lower

+                        } else {

+                                0

+                        }

                 ]

                 val types = p.types

-                val Map<Type,List<? extends Pair<Type,Integer>>> type2NewCost = new HashMap

-                for(type:types) {

+                val Map<Type, List<? extends Pair<Type, Integer>>> type2NewCost = new HashMap

+                for (type : types) {

                         val allSupertypes = (#[type] + type.supertypes).toSet

-                        val allOutgoingContainments = containments.filter[allSupertypes.contains((it.parameters.get(0) as ComplexTypeReference).referred)]

+                        val allOutgoingContainments = containments.filter [

+                                allSupertypes.contains((it.parameters.get(0) as ComplexTypeReference).referred)

+                        ]

                         val list = new LinkedList

-                        for(outgoingContainment : allOutgoingContainments) {

+                        for (outgoingContainment : allOutgoingContainments) {

                                 val value = containment2Lower.get(outgoingContainment)

-                                if(value>0) {

-                                        list.add((outgoingContainment.parameters.get(1) as ComplexTypeReference).referred

-                                                        ->      value)

+                                if (value > 0) {

+                                        list.add((outgoingContainment.parameters.get(1) as ComplexTypeReference).referred -> value)

                                 }

                         }

                         type2NewCost.put(type, list)

                 }

                 val res = new HashMap

-                for(containment : containments) {

+                for (containment : containments) {

                         val key = containment

                         val value = (containment.parameters.get(1) as ComplexTypeReference).referred.count(type2NewCost)

 //                      println('''«key.name» --> «value» new''')

-                        res.put(key,value)

+                        res.put(key, value)

                 }

                 return res

         }

-        

-        private def int count(Type t, Map<Type,List<? extends Pair<Type,Integer>>> containments) {

+

+        private def int count(Type t, Map<Type, List<? extends Pair<Type, Integer>>> containments) {

                 val list = containments.get(t)

                 var r = 1

-                for(element : list) {

+                for (element : list) {

                         r += element.value * element.key.count(containments)

                 }

                 return r

         }

-}
\ No newline at end of file
+}

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
index 23ea118b..dca10baf 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
@@ -1,5 +1,6 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules

 

+import com.google.common.collect.ImmutableList

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

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

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

@@ -15,7 +16,7 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.StringTypeReference
 import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type

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

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

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

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

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

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

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

@@ -27,78 +28,81 @@ import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.par
 import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialStringInterpretation

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

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

+import java.lang.reflect.Field

 import java.util.HashMap

+import java.util.Iterator

 import java.util.LinkedHashMap

 import java.util.LinkedList

 import java.util.List

 import java.util.Map

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

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

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

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

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

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

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

+import org.eclipse.viatra.query.runtime.rete.matcher.ReteBackendFactory

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

 import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRuleFactory

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

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

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

 

 class RefinementRuleProvider {

         val extension BatchTransformationRuleFactory factory = new BatchTransformationRuleFactory

         val extension PartialinterpretationFactory factory2 = PartialinterpretationFactory.eINSTANCE

         val extension LogiclanguageFactory factory3 = LogiclanguageFactory.eINSTANCE

-        

+

         def canonizeName(String name) {

-                return name.replace(' ','_')

+                return name.replace(' ', '_')

+        }

+

+        def createUnitPrulePropagator(LogicProblem p, PartialInterpretation i, GeneratedPatterns patterns,

+                ScopePropagator scopePropagator, ModelGenerationStatistics statistics) {

+                new UnitRulePropagator(p, i, this, scopePropagator, patterns.mustRelationPropagationQueries, statistics)

         }

-        

+

         def LinkedHashMap<ObjectCreationPrecondition, BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>> createObjectRefinementRules(

-                        LogicProblem p,

-                        PartialInterpretation i,

-                        GeneratedPatterns patterns,

-                        ScopePropagator scopePropagator,

-                        boolean nameNewElement,

-                        ModelGenerationStatistics statistics

-                )

-        {

+                LogicProblem p,

+                PartialInterpretation i,

+                GeneratedPatterns patterns,

+                UnitRulePropagator unitRulePropagator,

+                boolean nameNewElement,

+                ModelGenerationStatistics statistics

+        ) {

                 val res = new LinkedHashMap

-                val recursiveObjectCreation = recursiveObjectCreation(p,i)

-                for(LHSEntry: patterns.refineObjectQueries.entrySet) {

+                val recursiveObjectCreation = recursiveObjectCreation(p, i)

+                for (LHSEntry : patterns.refineObjectQueries.entrySet) {

                         val containmentRelation = LHSEntry.key.containmentRelation

                         val inverseRelation = LHSEntry.key.inverseContainment

                         val type = LHSEntry.key.newType

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

-                        val rule = createObjectCreationRule(p,containmentRelation,inverseRelation,type,recursiveObjectCreation.get(type),lhs,nameNewElement,scopePropagator,statistics)

-                        res.put(LHSEntry.key,rule)

+                        val rule = createObjectCreationRule(p, containmentRelation, inverseRelation, type,

+                                recursiveObjectCreation.get(type), lhs, nameNewElement, unitRulePropagator, statistics)

+                        res.put(LHSEntry.key, rule)

                 }

                 return res

         }

-        

-        def private createObjectCreationRule(

-                LogicProblem p,

-                Relation containmentRelation,

-                Relation inverseRelation,

-                Type type,

-                List<ObjectCreationInterpretationData> recursiceObjectCreations,

-                IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs,

-                boolean nameNewElement,

-                ScopePropagator scopePropagator,

-                ModelGenerationStatistics statistics)

-        {

-                val name = '''addObject_«type.name.canonizeName»«

-                                        IF containmentRelation!==null»_by_«containmentRelation.name.canonizeName»«ENDIF»'''

-                val ruleBuilder = factory.createRule

-                                .name(name)

-                                .precondition(lhs)

-                if(containmentRelation !== null) {

-                        if(inverseRelation!== null) {

-                                ruleBuilder.action[match |

-                                        //println(name)

+

+        def private createObjectCreationRule(LogicProblem p, Relation containmentRelation, Relation inverseRelation,

+                Type type, List<ObjectCreationInterpretationData> recursiveObjectCreations,

+                IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, boolean nameNewElement,

+                UnitRulePropagator unitRulePropagator, ModelGenerationStatistics statistics) {

+                val name = '''addObject_«type.name.canonizeName»«IF containmentRelation!==null»_by_«containmentRelation.name.canonizeName»«ENDIF»'''

+                val ruleBuilder = factory.createRule(lhs).name(name)

+                if (containmentRelation !== null) {

+                        if (inverseRelation !== null) {

+                                ruleBuilder.action [ match |

+                                        statistics.incrementTransformationCount

+//                                      println(name)

                                         val startTime = System.nanoTime

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

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

                                         val interpretation = match.get(1) as PartialInterpretation

                                         val relationInterpretation = match.get(2) as PartialRelationInterpretation

                                         val inverseRelationInterpretation = match.get(3) as PartialRelationInterpretation

                                         val typeInterpretation = match.get(4) as PartialComplexTypeInterpretation

                                         val container = match.get(5) as DefinedElement

-                                        

                                         createObjectActionWithContainmentAndInverse(

                                                 nameNewElement,

                                                 interpretation,

@@ -107,22 +111,24 @@ class RefinementRuleProvider {
                                                 relationInterpretation,

                                                 inverseRelationInterpretation,

                                                 [createDefinedElement],

-                                                recursiceObjectCreations,

-                                                scopePropagator

+                                                recursiveObjectCreations,

+                                                unitRulePropagator

                                         )

-                                        

-                                        statistics.addExecutionTime(System.nanoTime-startTime)

+                                        statistics.addExecutionTime(System.nanoTime - startTime)

+

+                                        unitRulePropagator.propagate

                                 ]

                         } else {

-                                ruleBuilder.action[match |

-                                        //println(name)

+                                ruleBuilder.action [ match |

+                                        statistics.incrementTransformationCount

+//                                      println(name)

                                         val startTime = System.nanoTime

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

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

                                         val interpretation = match.get(1) as PartialInterpretation

                                         val relationInterpretation = match.get(2) as PartialRelationInterpretation

                                         val typeInterpretation = match.get(3) as PartialComplexTypeInterpretation

                                         val container = match.get(4) as DefinedElement

-                                        

+

                                         createObjectActionWithContainment(

                                                 nameNewElement,

                                                 interpretation,

@@ -130,72 +136,80 @@ class RefinementRuleProvider {
                                                 container,

                                                 relationInterpretation,

                                                 [createDefinedElement],

-                                                recursiceObjectCreations,

-                                                scopePropagator

+                                                recursiveObjectCreations,

+                                                unitRulePropagator

                                         )

-                                        

-                                        statistics.addExecutionTime(System.nanoTime-startTime)

+                                        statistics.addExecutionTime(System.nanoTime - startTime)

+

+                                        unitRulePropagator.propagate

                                 ]

                         }

                 } else {

-                        ruleBuilder.action[match |

-                                //println(name)

+                        ruleBuilder.action [ match |

+                                statistics.incrementTransformationCount

+//                              println(name)

                                 val startTime = System.nanoTime

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

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

                                 val interpretation = match.get(1) as PartialInterpretation

                                 val typeInterpretation = match.get(2) as PartialComplexTypeInterpretation

-                                

+

                                 createObjectAction(

                                         nameNewElement,

                                         interpretation,

                                         typeInterpretation,

                                         [createDefinedElement],

-                                        recursiceObjectCreations,

-                                        scopePropagator

+                                        recursiveObjectCreations,

+                                        unitRulePropagator

                                 )

-                                

-                                statistics.addExecutionTime(System.nanoTime-startTime)

+                                statistics.addExecutionTime(System.nanoTime - startTime)

+

+                                unitRulePropagator.propagate

                         ]

                 }

                 return ruleBuilder.build

         }

-        

-        def private recursiveObjectCreation(LogicProblem p, PartialInterpretation i)

-        {

-                val Map<Type,List<ObjectCreationInterpretationData>> recursiveObjectCreation = new HashMap

-                for(type : p.types) {

-                        recursiveObjectCreation.put(type,new LinkedList)

+

+        def private recursiveObjectCreation(LogicProblem p, PartialInterpretation i) {

+                val Map<Type, List<ObjectCreationInterpretationData>> recursiveObjectCreation = new HashMap

+                for (type : p.types) {

+                        recursiveObjectCreation.put(type, new LinkedList)

                 }

-                

+

                 val containmentReferences = p.containmentHierarchies.head.containmentRelations

-                

-                for(relationInterpretation : i.partialrelationinterpretation) {

+

+                for (relationInterpretation : i.partialrelationinterpretation) {

                         val relation = relationInterpretation.interpretationOf

                         val lowermultiplicities = p.annotations.filter(LowerMultiplicityAssertion).filter[it.relation === relation]

-                        if((!lowermultiplicities.empty)) {

+                        if ((!lowermultiplicities.empty)) {

                                 val number = lowermultiplicities.head.lower

-                                if(number > 0) {

-                                        val sourceTypeInterpretation = getTypeInterpretation(i, relation, 0) as PartialComplexTypeInterpretation

-                                        val subtypeInterpretations = i.partialtypeinterpratation.filter(PartialComplexTypeInterpretation).filter[

-                                                it === sourceTypeInterpretation ||

-                                                it.supertypeInterpretation.contains(sourceTypeInterpretation)

-                                        ]

-                                        

-                                        if(containmentReferences.contains(relation)) {

+                                if (number > 0) {

+                                        val sourceTypeInterpretation = getTypeInterpretation(i, relation,

+                                                0) as PartialComplexTypeInterpretation

+                                        val subtypeInterpretations = i.partialtypeinterpratation.filter(PartialComplexTypeInterpretation).

+                                                filter [

+                                                        it === sourceTypeInterpretation ||

+                                                                it.supertypeInterpretation.contains(sourceTypeInterpretation)

+                                                ]

+

+                                        if (containmentReferences.contains(relation)) {

                                                 val targetTypeInterpretation = getTypeInterpretation(i, relation, 1)

                                                 val targetType = (targetTypeInterpretation as PartialComplexTypeInterpretation).interpretationOf

-                                                if((!targetType.isIsAbstract) && (targetType.supertypes.empty)) {

-                                                        val inverseAnnotation = p.annotations.filter(InverseRelationAssertion).filter[it.inverseA === relation || it.inverseB === relation]

-                                                        if(!inverseAnnotation.empty) {

-                                                                val onlyInverseAnnotation = if(inverseAnnotation.head.inverseA===relation) {

-                                                                        inverseAnnotation.head.inverseB

-                                                                } else {

-                                                                        inverseAnnotation.head.inverseA

-                                                                }

-                                                                val inverseRelationInterpretation = i.partialrelationinterpretation.filter[it.interpretationOf === onlyInverseAnnotation].head

-                                                                for(subTypeInterpretation : subtypeInterpretations) {

-                                                                        for(var times=0; times<number; times++) {

-                                                                                recursiveObjectCreation.get(subTypeInterpretation.interpretationOf) += 

+                                                if ((!targetType.isIsAbstract) && (targetType.supertypes.empty)) {

+                                                        val inverseAnnotation = p.annotations.filter(InverseRelationAssertion).filter [

+                                                                it.inverseA === relation || it.inverseB === relation

+                                                        ]

+                                                        if (!inverseAnnotation.empty) {

+                                                                val onlyInverseAnnotation = if (inverseAnnotation.head.inverseA === relation) {

+                                                                                inverseAnnotation.head.inverseB

+                                                                        } else {

+                                                                                inverseAnnotation.head.inverseA

+                                                                        }

+                                                                val inverseRelationInterpretation = i.partialrelationinterpretation.filter [

+                                                                        it.interpretationOf === onlyInverseAnnotation

+                                                                ].head

+                                                                for (subTypeInterpretation : subtypeInterpretations) {

+                                                                        for (var times = 0; times < number; times++) {

+                                                                                recursiveObjectCreation.get(subTypeInterpretation.interpretationOf) +=

                                                                                         new ObjectCreationInterpretationData(

                                                                                                 i,

                                                                                                 targetTypeInterpretation,

@@ -206,9 +220,9 @@ class RefinementRuleProvider {
                                                                         }

                                                                 }

                                                         } else {

-                                                                for(subTypeInterpretation : subtypeInterpretations) {

-                                                                        for(var times=0; times<number; times++) {

-                                                                                recursiveObjectCreation.get(subTypeInterpretation.interpretationOf) += 

+                                                                for (subTypeInterpretation : subtypeInterpretations) {

+                                                                        for (var times = 0; times < number; times++) {

+                                                                                recursiveObjectCreation.get(subTypeInterpretation.interpretationOf) +=

                                                                                         new ObjectCreationInterpretationData(

                                                                                                 i,

                                                                                                 targetTypeInterpretation,

@@ -220,11 +234,11 @@ class RefinementRuleProvider {
                                                                 }

                                                         }

                                                 }

-                                        } else if(relation.parameters.get(1) instanceof PrimitiveTypeReference) {

+                                        } else if (relation.parameters.get(1) instanceof PrimitiveTypeReference) {

                                                 val targetTypeInterpretation = getTypeInterpretation(i, relation, 1)

-                                                for(subTypeInterpretation : subtypeInterpretations) {

-                                                        for(var times=0; times<number; times++) {

-                                                                recursiveObjectCreation.get(subTypeInterpretation.interpretationOf) += 

+                                                for (subTypeInterpretation : subtypeInterpretations) {

+                                                        for (var times = 0; times < number; times++) {

+                                                                recursiveObjectCreation.get(subTypeInterpretation.interpretationOf) +=

                                                                         new ObjectCreationInterpretationData(

                                                                                 i,

                                                                                 targetTypeInterpretation,

@@ -238,129 +252,134 @@ class RefinementRuleProvider {
                                 }

                         }

                 }

-                

+

                 // Doing the recursion

                 var objectCreations = new LinkedList(recursiveObjectCreation.values.flatten.toList)

-                for(objectCreation : objectCreations) {

+                for (objectCreation : objectCreations) {

                         val newInterpretation = objectCreation.typeInterpretation

-                        if(newInterpretation instanceof PartialComplexTypeInterpretation) {

+                        if (newInterpretation instanceof PartialComplexTypeInterpretation) {

                                 val newlyCreatedType = newInterpretation.interpretationOf

-                                if(recursiveObjectCreation.containsKey(newlyCreatedType)) {

+                                if (recursiveObjectCreation.containsKey(newlyCreatedType)) {

                                         val actionsWhenTypeCreated = recursiveObjectCreation.get(newlyCreatedType)

-                                        objectCreation.recursiveConstructors+=actionsWhenTypeCreated

+                                        objectCreation.recursiveConstructors += actionsWhenTypeCreated

                                 }

                         }

                 }

-                

+

                 // checking acyclicity

-                for(objectCreation : objectCreations) {

+                for (objectCreation : objectCreations) {

                         var reachable = objectCreation.recursiveConstructors

                         do {

-                                if(reachable.contains(objectCreation)) {

+                                if (reachable.contains(objectCreation)) {

                                         throw new IllegalArgumentException('''Cicrle in the containment!''')

                                 } else {

                                         reachable = reachable.map[it.recursiveConstructors].flatten.toList

                                 }

-                        } while(!reachable.empty)

-                }       

-                

+                        } while (!reachable.empty)

+                }

+

                 return recursiveObjectCreation

         }

-        

+

         private def getTypeInterpretation(PartialInterpretation i, RelationDeclaration relation, int index) {

                 val typeReference = relation.parameters.get(index)

-                return getTypeInterpretation(i,typeReference)

-                

+                return getTypeInterpretation(i, typeReference)

+

         }

+

         private dispatch def getTypeInterpretation(PartialInterpretation i, ComplexTypeReference reference) {

-                return i.partialtypeinterpratation

-                                .filter(PartialComplexTypeInterpretation)

-                                .filter[it.getInterpretationOf == reference.referred]

-                                .head

+                return i.partialtypeinterpratation.filter(PartialComplexTypeInterpretation).filter [

+                        it.getInterpretationOf == reference.referred

+                ].head

         }

+

         private dispatch def getTypeInterpretation(PartialInterpretation i, BoolTypeReference reference) {

-                return i.partialtypeinterpratation

-                                .filter(PartialBooleanInterpretation)

-                                .head

+                return i.partialtypeinterpratation.filter(PartialBooleanInterpretation).head

         }

+

         private dispatch def getTypeInterpretation(PartialInterpretation i, IntTypeReference reference) {

-                return i.partialtypeinterpratation

-                                .filter(PartialIntegerInterpretation)

-                                .head

+                return i.partialtypeinterpratation.filter(PartialIntegerInterpretation).head

         }

+

         private dispatch def getTypeInterpretation(PartialInterpretation i, RealTypeReference reference) {

-                return i.partialtypeinterpratation

-                                .filter(PartialRealInterpretation)

-                                .head

+                return i.partialtypeinterpratation.filter(PartialRealInterpretation).head

         }

+

         private dispatch def getTypeInterpretation(PartialInterpretation i, StringTypeReference reference) {

-                return i.partialtypeinterpratation

-                                .filter(PartialStringInterpretation)

-                                .head

+                return i.partialtypeinterpratation.filter(PartialStringInterpretation).head

         }

-        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialComplexTypeInterpretation reference) { [createDefinedElement] }

-        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialBooleanInterpretation reference) { [createBooleanElement] }

-        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialIntegerInterpretation reference) { [createIntegerElement] }

-        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialRealInterpretation reference) { [createRealElement] }

-        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialStringInterpretation reference) { [createStringElement] }

-        

-        

-        def createRelationRefinementRules(GeneratedPatterns patterns, ModelGenerationStatistics statistics) {

+

+        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialComplexTypeInterpretation reference) {

+                [createDefinedElement]

+        }

+

+        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialBooleanInterpretation reference) {

+                [createBooleanElement]

+        }

+

+        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialIntegerInterpretation reference) {

+                [createIntegerElement]

+        }

+

+        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialRealInterpretation reference) {

+                [createRealElement]

+        }

+

+        private dispatch def Function0<DefinedElement> getTypeConstructor(PartialStringInterpretation reference) {

+                [createStringElement]

+        }

+

+        def createRelationRefinementRules(GeneratedPatterns patterns, UnitRulePropagator unitRulePropagator,

+                ModelGenerationStatistics statistics) {

                 val res = new LinkedHashMap

-                for(LHSEntry: patterns.refinerelationQueries.entrySet) {

+                for (LHSEntry : patterns.refineRelationQueries.entrySet) {

                         val declaration = LHSEntry.key.key

                         val inverseReference = LHSEntry.key.value

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

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

-                        res.put(LHSEntry.key,rule)

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

+                        res.put(LHSEntry.key, rule)

                 }

                 return res

         }

-        

-        def private BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>

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

-        {

+

+        def private BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>> createRelationRefinementRule(

+                RelationDeclaration declaration, Relation inverseRelation,

+                IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, UnitRulePropagator unitRulePropagator,

+                ModelGenerationStatistics statistics) {

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

-                val ruleBuilder = factory.createRule

-                        .name(name)

-                        .precondition(lhs)

+                val ruleBuilder = factory.createRule(lhs).name(name)

                 if (inverseRelation === null) {

                         ruleBuilder.action [ match |

-                            val startTime = System.nanoTime

-                                //println(name)

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

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

-                                val relationInterpretation = match.get(2) as PartialRelationInterpretation

-                                val src = match.get(3) as DefinedElement

-                                val trg = match.get(4) as DefinedElement

-                                createRelationLinkAction(src, trg, relationInterpretation)

-                statistics.addExecutionTime(System.nanoTime-startTime)

+                                statistics.incrementTransformationCount

+//                              println(name)

+                                val startTime = System.nanoTime

+                                createRelationLinkAction(match, unitRulePropagator)

+                                statistics.addExecutionTime(System.nanoTime - startTime)

+

+                                unitRulePropagator.propagate

                         ]

                 } else {

                         ruleBuilder.action [ match |

-                            val startTime = System.nanoTime

-                                //println(name)

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

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

-                                val relationInterpretation = match.get(2) as PartialRelationInterpretation

-                                val inverseInterpretation = match.get(3) as PartialRelationInterpretation

-                                val src = match.get(4) as DefinedElement

-                                val trg = match.get(5) as DefinedElement

-                                createRelationLinkWithInverse(src, trg, relationInterpretation, inverseInterpretation)

-                                statistics.addExecutionTime(System.nanoTime-startTime)

+                                statistics.incrementTransformationCount

+//                              println(name)

+                                val startTime = System.nanoTime

+                                createRelationLinkWithInverse(match, unitRulePropagator)

+                                statistics.addExecutionTime(System.nanoTime - startTime)

+

+                                unitRulePropagator.propagate

                         ]

                 }

 

                 return ruleBuilder.build

         }

-        

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

+

+        // ///////////////////////

         // Actions

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

-        

-        protected def void createObjectAction(boolean nameNewElement, ObjectCreationInterpretationData data, DefinedElement container, ScopePropagator scopePropagator) {

-                if(data.containerInterpretation !== null) {

-                        if(data.containerInverseInterpretation !== null) {

+        // ///////////////////////

+        protected def void createObjectAction(boolean nameNewElement, ObjectCreationInterpretationData data,

+                DefinedElement container, UnitRulePropagator unitRulePropagator) {

+                if (data.containerInterpretation !== null) {

+                        if (data.containerInverseInterpretation !== null) {

                                 createObjectActionWithContainmentAndInverse(

                                         nameNewElement,

                                         data.interpretation,

@@ -370,7 +389,7 @@ class RefinementRuleProvider {
                                         data.containerInverseInterpretation,

                                         data.constructor,

                                         data.recursiveConstructors,

-                                        scopePropagator

+                                        unitRulePropagator

                                 )

                         } else {

                                 createObjectActionWithContainment(

@@ -381,7 +400,7 @@ class RefinementRuleProvider {
                                         data.containerInterpretation,

                                         data.constructor,

                                         data.recursiveConstructors,

-                                        scopePropagator

+                                        unitRulePropagator

                                 )

                         }

                 } else {

@@ -391,12 +410,12 @@ class RefinementRuleProvider {
                                 data.typeInterpretation,

                                 data.constructor,

                                 data.recursiveConstructors,

-                                scopePropagator

+                                unitRulePropagator

                         )

                 }

-                

+

         }

-        

+

         protected def createObjectActionWithContainmentAndInverse(

                 boolean nameNewElement,

                 PartialInterpretation interpretation,

@@ -406,39 +425,41 @@ class RefinementRuleProvider {
                 PartialRelationInterpretation inverseRelationInterpretation,

                 Function0<DefinedElement> constructor,

                 List<ObjectCreationInterpretationData> recursiceObjectCreations,

-                ScopePropagator scopePropagator

+                UnitRulePropagator unitRulePropagator

         ) {

                 val newElement = constructor.apply

-                if(nameNewElement) {

+                if (nameNewElement) {

                         newElement.name = '''new «interpretation.newElements.size»'''

                 }

-                

+

                 // Types

                 typeInterpretation.elements += newElement

-                if(typeInterpretation instanceof PartialComplexTypeInterpretation) {

+                if (typeInterpretation instanceof PartialComplexTypeInterpretation) {

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

                 }

                 // ContainmentRelation

                 val newLink1 = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement]

-                relationInterpretation.relationlinks+=newLink1

+                relationInterpretation.relationlinks += newLink1

                 // Inverse Containment

                 val newLink2 = factory2.createBinaryElementRelationLink => [it.param1 = newElement it.param2 = container]

-                inverseRelationInterpretation.relationlinks+=newLink2

-                

+                inverseRelationInterpretation.relationlinks += newLink2

+

                 // Scope propagation

-                scopePropagator.propagateAdditionToType(typeInterpretation)

-                

+                unitRulePropagator.decrementTypeScope(typeInterpretation)

+                unitRulePropagator.addedToRelation(relationInterpretation.interpretationOf)

+                unitRulePropagator.addedToRelation(inverseRelationInterpretation.interpretationOf)

+

                 // Existence

-                interpretation.newElements+=newElement

-                

+                interpretation.newElements += newElement

+

                 // Do recursive object creation

-                for(newConstructor : recursiceObjectCreations) {

-                        createObjectAction(nameNewElement,newConstructor,newElement,scopePropagator)

+                for (newConstructor : recursiceObjectCreations) {

+                        createObjectAction(nameNewElement, newConstructor, newElement, unitRulePropagator)

                 }

-                

+

                 return newElement

         }

-        

+

         protected def createObjectActionWithContainment(

                 boolean nameNewElement,

                 PartialInterpretation interpretation,

@@ -447,79 +468,267 @@ class RefinementRuleProvider {
                 PartialRelationInterpretation relationInterpretation,

                 Function0<DefinedElement> constructor,

                 List<ObjectCreationInterpretationData> recursiceObjectCreations,

-                ScopePropagator scopePropagator

+                UnitRulePropagator unitRulePropagator

         ) {

                 val newElement = constructor.apply

-                if(nameNewElement) {

+                if (nameNewElement) {

                         newElement.name = '''new «interpretation.newElements.size»'''

                 }

-                

+

                 // Types

                 typeInterpretation.elements += newElement

-                if(typeInterpretation instanceof PartialComplexTypeInterpretation) {

+                if (typeInterpretation instanceof PartialComplexTypeInterpretation) {

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

                 }

                 // ContainmentRelation

                 val newLink = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement]

-                relationInterpretation.relationlinks+=newLink

-                

+                relationInterpretation.relationlinks += newLink

+                unitRulePropagator.addedToRelation(relationInterpretation.interpretationOf)

+

                 // Scope propagation

-                scopePropagator.propagateAdditionToType(typeInterpretation)

-                

+                unitRulePropagator.decrementTypeScope(typeInterpretation)

+

                 // Existence

-                interpretation.newElements+=newElement

-                

+                interpretation.newElements += newElement

+

                 // Do recursive object creation

-                for(newConstructor : recursiceObjectCreations) {

-                        createObjectAction(nameNewElement,newConstructor,newElement,scopePropagator)

+                for (newConstructor : recursiceObjectCreations) {

+                        createObjectAction(nameNewElement, newConstructor, newElement, unitRulePropagator)

                 }

-                

+

                 return newElement

         }

-        

-        protected def createObjectAction(

-                boolean nameNewElement,

-                PartialInterpretation interpretation,

-                PartialTypeInterpratation typeInterpretation,

-                Function0<DefinedElement> constructor,

-                List<ObjectCreationInterpretationData> recursiceObjectCreations,

-                ScopePropagator scopePropagator)

-        {

+

+        protected def createObjectAction(boolean nameNewElement, PartialInterpretation interpretation,

+                PartialTypeInterpratation typeInterpretation, Function0<DefinedElement> constructor,

+                List<ObjectCreationInterpretationData> recursiceObjectCreations, UnitRulePropagator unitRulePropagator) {

                 val newElement = constructor.apply

-                if(nameNewElement) {

+                if (nameNewElement) {

                         newElement.name = '''new «interpretation.newElements.size»'''

                 }

-                

+

                 // Types

                 typeInterpretation.elements += newElement

-                if(typeInterpretation instanceof PartialComplexTypeInterpretation) {

+                if (typeInterpretation instanceof PartialComplexTypeInterpretation) {

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

                 }

-                

+

                 // Scope propagation

-                scopePropagator.propagateAdditionToType(typeInterpretation)

-                

+                unitRulePropagator.decrementTypeScope(typeInterpretation)

+

                 // Existence

-                interpretation.newElements+=newElement

-                

+                interpretation.newElements += newElement

+

                 // Do recursive object creation

-                for(newConstructor : recursiceObjectCreations) {

-                        createObjectAction(nameNewElement,newConstructor,newElement,scopePropagator)

+                for (newConstructor : recursiceObjectCreations) {

+                        createObjectAction(nameNewElement, newConstructor, newElement, unitRulePropagator)

                 }

-                

+

                 return newElement

         }

-        

-        protected def boolean createRelationLinkAction(DefinedElement src, DefinedElement trg, PartialRelationInterpretation relationInterpretation) {

+

+        protected def createRelationLinkAction(IPatternMatch match, UnitRulePropagator unitRulePropagator) {

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

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

+                val relationInterpretation = match.get(2) as PartialRelationInterpretation

+                val src = match.get(3) as DefinedElement

+                val trg = match.get(4) as DefinedElement

+                createRelationLinkAction(src, trg, relationInterpretation, unitRulePropagator)

+        }

+

+        protected def void createRelationLinkAction(DefinedElement src, DefinedElement trg,

+                PartialRelationInterpretation relationInterpretation, UnitRulePropagator unitRulePropagator) {

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

                 relationInterpretation.relationlinks += link

+                unitRulePropagator.addedToRelation(relationInterpretation.interpretationOf)

         }

-        

-        protected def boolean createRelationLinkWithInverse(DefinedElement src, DefinedElement trg, PartialRelationInterpretation relationInterpretation, PartialRelationInterpretation inverseInterpretation) {

+

+        protected def void createRelationLinkWithInverse(IPatternMatch match, UnitRulePropagator unitRulePropagator) {

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

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

+                val relationInterpretation = match.get(2) as PartialRelationInterpretation

+                val inverseInterpretation = match.get(3) as PartialRelationInterpretation

+                val src = match.get(4) as DefinedElement

+                val trg = match.get(5) as DefinedElement

+                createRelationLinkWithInverse(src, trg, relationInterpretation, inverseInterpretation, unitRulePropagator)

+        }

+

+        protected def void createRelationLinkWithInverse(DefinedElement src, DefinedElement trg,

+                PartialRelationInterpretation relationInterpretation, PartialRelationInterpretation inverseInterpretation,

+                UnitRulePropagator unitRulePropagator) {

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

                 relationInterpretation.relationlinks += link

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

                 inverseInterpretation.relationlinks += inverseLink

+                unitRulePropagator.addedToRelation(relationInterpretation.interpretationOf)

+                unitRulePropagator.addedToRelation(inverseInterpretation.interpretationOf)

+        }

+

+        static class UnitRulePropagator {

+                val LogicProblem p

+                val PartialInterpretation i

+                val RefinementRuleProvider refinementRuleProvider

+                var AdvancedViatraQueryEngine queryEngine

+                var Field delayMessageDelivery

+                val ScopePropagator scopePropagator

+                val List<AbstractMustRelationPropagator<? extends IPatternMatch>> propagators

+                val ModelGenerationStatistics statistics

+

+                new(LogicProblem p, PartialInterpretation i, RefinementRuleProvider refinementRuleProvider,

+                        ScopePropagator scopePropagator,

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

+                        ModelGenerationStatistics statistics) {

+                        this.p = p

+                        this.i = i

+                        this.refinementRuleProvider = refinementRuleProvider

+                        queryEngine = ViatraQueryEngine.on(new EMFScope(i)) as AdvancedViatraQueryEngine

+                        delayMessageDelivery = queryEngine.class.getDeclaredField("delayMessageDelivery")

+                        delayMessageDelivery.accessible = true

+                        this.scopePropagator = scopePropagator

+                        propagators = ImmutableList.copyOf(mustRelationPropagationQueries.entrySet.map [ entry |

+                                val matcher = queryEngine.getMatcher(entry.value)

+                                getPropagator(entry.key.key, entry.key.value, matcher)

+                        ])

+                        this.statistics = statistics

+                }

+

+                def decrementTypeScope(PartialTypeInterpratation partialTypeInterpratation) {

+                        scopePropagator.decrementTypeScope(partialTypeInterpratation)

+                }

+

+                def addedToRelation(Relation r) {

+                        scopePropagator.addedToRelation(r)

+                }

+

+                def propagate() {

+                        var boolean changed

+                        do {

+                                val scopeChanged = propagateScope()

+                                val mustChanged = propagateMustRelations()

+                                changed = scopeChanged || mustChanged

+                        } while (changed)

+                }

+

+                protected def flushQueryEngine() {

+                        if (queryEngine.updatePropagationDelayed) {

+                                delayMessageDelivery.setBoolean(queryEngine, false)

+                                queryEngine.getQueryBackend(ReteBackendFactory.INSTANCE).flushUpdates

+                                delayMessageDelivery.setBoolean(queryEngine, true)

+                        }

+                }

+

+                protected def propagateScope() {

+                        if (scopePropagator.scopePropagationNeeded) {

+                                if (scopePropagator.queryEngineFlushRequiredBeforePropagation) {

+                                        flushQueryEngine()

+                                }

+                                val propagatorStartTime = System.nanoTime

+                                scopePropagator.propagateAllScopeConstraints()

+                                statistics.addScopePropagationTime(System.nanoTime - propagatorStartTime)

+                                true

+                        } else {

+                                false

+                        }

+                }

+

+                protected def propagateMustRelations() {

+                        if (propagators.empty) {

+                                return false

+                        }

+                        flushQueryEngine()

+                        val propagatorStartTime = System.nanoTime

+                        var changed = false

+                        for (propagator : propagators) {

+                                changed = propagator.propagate(p, i, refinementRuleProvider, this) || changed

+                        }

+                        statistics.addMustRelationPropagationTime(System.nanoTime - propagatorStartTime)

+                        changed

+                }

+

+                private static def <T extends IPatternMatch> getPropagator(Relation relation, Relation inverseRelation,

+                        ViatraQueryMatcher<T> matcher) {

+                        if (inverseRelation === null) {

+                                new MustRelationPropagator(matcher)

+                        } else if (relation == inverseRelation) {

+                                new MustRelationPropagatorWithSelfInverse(matcher)

+                        } else {

+                                new MustRelationPropagatorWithInverse(matcher)

+                        }

+                }

+

+                @FinalFieldsConstructor

+                private static abstract class AbstractMustRelationPropagator<T extends IPatternMatch> {

+                        val ViatraQueryMatcher<T> matcher

+

+                        def propagate(LogicProblem p, PartialInterpretation i, RefinementRuleProvider refinementRuleProvider,

+                                UnitRulePropagator unitRulePropagator) {

+                                val iterator = getIterator(p, i)

+                                if (!iterator.hasNext) {

+                                        return false

+                                }

+                                iterate(iterator, refinementRuleProvider, unitRulePropagator)

+                                true

+                        }

+

+                        def iterate(Iterator<T> iterator, RefinementRuleProvider refinementRuleProvider,

+                                UnitRulePropagator unitRulePropagator) {

+                                while (iterator.hasNext) {

+                                        doPropagate(iterator.next, refinementRuleProvider, unitRulePropagator)

+                                }

+                        }

+

+                        protected def getIterator(LogicProblem p, PartialInterpretation i) {

+                                val partialMatch = matcher.newEmptyMatch

+                                partialMatch.set(0, p)

+                                partialMatch.set(1, i)

+                                matcher.streamAllMatches(partialMatch).iterator

+                        }

+

+                        protected def void doPropagate(T match, RefinementRuleProvider refinementRuleProvider,

+                                UnitRulePropagator unitRulePropagator)

+                }

+

+                private static class MustRelationPropagator<T extends IPatternMatch> extends AbstractMustRelationPropagator<T> {

+                        new(ViatraQueryMatcher<T> matcher) {

+                                super(matcher)

+                        }

+

+                        override protected doPropagate(T match, RefinementRuleProvider refinementRuleProvider,

+                                UnitRulePropagator unitRulePropagator) {

+                                refinementRuleProvider.createRelationLinkAction(match, unitRulePropagator)

+                        }

+                }

+

+                private static class MustRelationPropagatorWithInverse<T extends IPatternMatch> extends AbstractMustRelationPropagator<T> {

+                        new(ViatraQueryMatcher<T> matcher) {

+                                super(matcher)

+                        }

+

+                        override protected doPropagate(T match, RefinementRuleProvider refinementRuleProvider,

+                                UnitRulePropagator unitRulePropagator) {

+                                refinementRuleProvider.createRelationLinkWithInverse(match, unitRulePropagator)

+                        }

+                }

+

+                private static class MustRelationPropagatorWithSelfInverse<T extends IPatternMatch> extends MustRelationPropagatorWithInverse<T> {

+                        new(ViatraQueryMatcher<T> matcher) {

+                                super(matcher)

+                        }

+

+                        override iterate(Iterator<T> iterator, RefinementRuleProvider refinementRuleProvider,

+                                UnitRulePropagator unitRulePropagator) {

+                                val pairs = newHashSet

+                                while (iterator.hasNext) {

+                                        val match = iterator.next

+                                        val src = match.get(4) as DefinedElement

+                                        val trg = match.get(5) as DefinedElement

+                                        if (!pairs.contains(trg -> src)) {

+                                                pairs.add(src -> trg)

+                                                doPropagate(match, refinementRuleProvider, unitRulePropagator)

+                                        }

+                                }

+                        }

+                }

         }

 }