12 files changed, 929 insertions, 0 deletions

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/AbstractThreeValuedObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/AbstractThreeValuedObjective.xtend
new file mode 100644
index 00000000..cd911ab5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/AbstractThreeValuedObjective.xtend
@@ -0,0 +1,35 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import org.eclipse.viatra.dse.base.ThreadContext
+
+abstract class AbstractThreeValuedObjective extends DirectionalThresholdObjective implements IThreeValuedObjective {
+        protected new(String name, ObjectiveKind kind, ObjectiveThreshold threshold, int level) {
+                super(name, kind, threshold, level)
+        }
+
+        abstract def double getLowestPossibleFitness(ThreadContext threadContext)
+
+        abstract def double getHighestPossibleFitness(ThreadContext threadContext)
+
+        override getWorstPossibleFitness(ThreadContext threadContext) {
+                switch (kind) {
+                        case LOWER_IS_BETTER:
+                                getHighestPossibleFitness(threadContext)
+                        case HIGHER_IS_BETTER:
+                                getLowestPossibleFitness(threadContext)
+                        default:
+                                throw new IllegalStateException("Unknown three valued objective kind: " + kind)
+                }
+        }
+
+        override getBestPossibleFitness(ThreadContext threadContext) {
+                switch (kind) {
+                        case LOWER_IS_BETTER:
+                                getLowestPossibleFitness(threadContext)
+                        case HIGHER_IS_BETTER:
+                                getHighestPossibleFitness(threadContext)
+                        default:
+                                throw new IllegalStateException("Unknown three valued objective kind: " + kind)
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CompositeDirectionalThresholdObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CompositeDirectionalThresholdObjective.xtend
new file mode 100644
index 00000000..0aa442f5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CompositeDirectionalThresholdObjective.xtend
@@ -0,0 +1,62 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import com.google.common.collect.ImmutableList
+import java.util.Collection
+import org.eclipse.viatra.dse.base.ThreadContext
+
+class CompositeDirectionalThresholdObjective extends DirectionalThresholdObjective {
+        val Collection<DirectionalThresholdObjective> objectives
+
+        new(String name, Collection<DirectionalThresholdObjective> objectives) {
+                this(name, objectives, getKind(objectives), getThreshold(objectives), getLevel(objectives))
+        }
+
+        new(String name, DirectionalThresholdObjective... objectives) {
+                this(name, objectives as Collection<DirectionalThresholdObjective>)
+        }
+
+        protected new(String name, Iterable<DirectionalThresholdObjective> objectives, ObjectiveKind kind,
+                ObjectiveThreshold threshold, int level) {
+                super(name, kind, threshold, level)
+                this.objectives = ImmutableList.copyOf(objectives)
+        }
+
+        override createNew() {
+                new CompositeDirectionalThresholdObjective(name, objectives.map[createNew as DirectionalThresholdObjective],
+                        kind, threshold, level)
+        }
+
+        override init(ThreadContext context) {
+                for (objective : objectives) {
+                        objective.init(context)
+                }
+        }
+
+        override protected getRawFitness(ThreadContext context) {
+                var double fitness = 0
+                for (objective : objectives) {
+                        fitness += objective.getFitness(context)
+                }
+                fitness
+        }
+
+        private static def getKind(Collection<DirectionalThresholdObjective> objectives) {
+                val kinds = objectives.map[kind].toSet
+                if (kinds.size != 1) {
+                        throw new IllegalArgumentException("Passed objectives must have the same kind")
+                }
+                kinds.head
+        }
+
+        private static def getThreshold(Collection<DirectionalThresholdObjective> objectives) {
+                objectives.map[threshold].reduce[a, b|a.merge(b)]
+        }
+
+        private static def int getLevel(Collection<DirectionalThresholdObjective> objectives) {
+                val levels = objectives.map[level].toSet
+                if (levels.size != 1) {
+                        throw new IllegalArgumentException("Passed objectives must have the same level")
+                }
+                levels.head
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CostElementMatchers.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CostElementMatchers.xtend
new file mode 100644
index 00000000..885b14e8
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CostElementMatchers.xtend
@@ -0,0 +1,137 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import com.google.common.collect.ImmutableList
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage
+import java.util.List
+import org.eclipse.emf.ecore.EObject
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.xtend.lib.annotations.Data
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+
+@FunctionalInterface
+interface ParameterScopeBound {
+        def double getUpperBound()
+}
+
+@Data
+class CostElementMatch {
+        val IPatternMatch match
+        val boolean must
+
+        def isMulti() {
+                CostElementMatchers.isMultiMatch(match)
+        }
+}
+
+@Data
+class CostElementMatchers {
+        val ViatraQueryMatcher<? extends IPatternMatch> currentMatcher
+        val ViatraQueryMatcher<? extends IPatternMatch> mayMatcher
+        val ViatraQueryMatcher<? extends IPatternMatch> mustMatcher
+        val List<ParameterScopeBound> parameterScopeBounds
+        val int weight
+
+        def getCurrentNumberOfMatches() {
+                currentMatcher.countMatches
+        }
+
+        def getMinimumNumberOfMatches() {
+                mustMatcher.countMatches
+        }
+
+        def getMaximumNumberOfMatches() {
+                var double sum = 0
+                val iterator = mayMatcher.streamAllMatches.iterator
+                while (iterator.hasNext) {
+                        val match = iterator.next
+                        var double product = 1
+                        val numberOfParameters = parameterScopeBounds.size
+                        for (var int i = 0; i < numberOfParameters; i++) {
+                                if (isMulti(match.get(i + 2))) {
+                                        val scopeBound = parameterScopeBounds.get(i)
+                                        product *= scopeBound.upperBound
+                                }
+
+                        }
+                        sum += product
+                }
+                sum
+        }
+
+        def getMatches() {
+                ImmutableList.copyOf(mayMatcher.streamAllMatches.iterator.map [ match |
+                        new CostElementMatch(match, mustMatcher.isMatch(match))
+                ])
+        }
+        
+        def projectMayMatch(IPatternMatch match, int... indices) {
+                mayMatcher.projectMatch(match, indices)
+        }
+        
+        private static def <T extends IPatternMatch> projectMatch(ViatraQueryMatcher<T> matcher, IPatternMatch match, int... indices) {
+                checkMatch(match)
+                val n = matcher.specification.parameters.length - 2
+                if (indices.length != n) {
+                        throw new IllegalArgumentException("Invalid number of projection indices")
+                }
+                val newMatch = matcher.newEmptyMatch
+                newMatch.set(0, match.get(0))
+                newMatch.set(1, match.get(1))
+                for (var int i = 0; i < n; i++) {
+                        newMatch.set(i + 2, match.get(indices.get(i)))
+                }
+                if (!matcher.hasMatch(newMatch)) {
+                        throw new IllegalArgumentException("Projected match does not exist")
+                }
+                return newMatch
+        }
+
+        private static def <T extends IPatternMatch> isMatch(ViatraQueryMatcher<T> matcher, IPatternMatch match) {
+                val n = matcher.specification.parameters.length
+                if (n != match.specification.parameters.length) {
+                        throw new IllegalArgumentException("Invalid number of match arguments")
+                }
+                val newMatch = matcher.newEmptyMatch
+                for (var int i = 0; i < n; i++) {
+                        newMatch.set(i, match.get(i))
+                }
+                return matcher.hasMatch(newMatch)
+        }
+
+        static def isMulti(Object o) {
+                if (o instanceof EObject) {
+                        switch (feature : o.eContainmentFeature) {
+                                case LogicproblemPackage.eINSTANCE.logicProblem_Elements,
+                                case PartialinterpretationPackage.eINSTANCE.partialInterpretation_NewElements:
+                                        false
+                                case PartialinterpretationPackage.eINSTANCE.partialInterpretation_OpenWorldElements:
+                                        true
+                                default:
+                                        throw new IllegalStateException("Unknown containment feature for element: " + feature)
+                        }
+                } else {
+                        false
+                }
+        }
+
+        static def isMultiMatch(IPatternMatch match) {
+                checkMatch(match)
+                val n = match.specification.parameters.length
+                for (var int i = 2; i < n; i++) {
+                        if (isMulti(match.get(i))) {
+                                return true
+                        }
+                }
+                false
+        }
+        
+        private static def checkMatch(IPatternMatch match) {
+                val n = match.specification.parameters.length
+                if (n < 2 || !(match.get(0) instanceof LogicProblem) || !(match.get(1) instanceof PartialInterpretation)) {
+                        throw new IllegalArgumentException("Match is not from the partial interpretation")
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CostObjectiveHint.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CostObjectiveHint.xtend
new file mode 100644
index 00000000..2434073d
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/CostObjectiveHint.xtend
@@ -0,0 +1,68 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.BoundSaturationListener
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ExtendedLinearExpressionBuilder
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearTypeConstraintHint
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearTypeExpressionBuilderFactory
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronExtensionOperator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PatternGenerator
+import java.util.Map
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
+import org.eclipse.xtend.lib.annotations.Accessors
+
+abstract class CostObjectiveHint implements LinearTypeConstraintHint, BoundSaturationListener {
+        @Accessors ThreeValuedCostObjective objective
+        @Accessors IObjectiveBoundsProvider boundsProvider
+        
+        Integer bestUpper = null
+
+        override getAdditionalPatterns(PatternGenerator patternGenerator, Map<String, PQuery> fqnToPQuery) {
+                ''''''
+        }
+
+        override createConstraintUpdater(LinearTypeExpressionBuilderFactory builderFactory) {
+                null
+        }
+        
+        def isExact() {
+                false
+        }
+
+        def PolyhedronExtensionOperator createPolyhedronExtensionOperator(
+                Map<String, CostElementMatchers> costElementMatchers) {
+                null
+        }
+        
+        def setObjective(ThreeValuedCostObjective objective) {
+                if (this.objective !== null) {
+                        throw new IllegalStateException("Objective was already set")
+                }
+                this.objective = objective
+        }
+        
+        def setBoundsProvider(IObjectiveBoundsProvider boundsProvider) {
+                if (this.boundsProvider !== null) {
+                        throw new IllegalStateException("Objective bounds provider was already set")
+                }
+                this.boundsProvider = boundsProvider
+        }
+        
+        protected def buildWithBounds(ExtendedLinearExpressionBuilder builder) {
+                val bounds = builder.build(this)
+                if (objective !== null && boundsProvider !== null) {
+                        boundsProvider.computeRequiredBounds(objective, bounds)
+                }
+                if (exact && bestUpper !== null) {
+                        bounds.tightenLowerBound(bestUpper)
+                }
+                bounds
+        }
+        
+        override boundsSaturated(Integer lower, Integer upper) {
+                if (upper !== null && (bestUpper === null || bestUpper < upper)) {
+                        bestUpper = upper
+                }
+                objective?.boundsSaturated(lower, upper)
+        }
+        
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/DirectionalThresholdObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/DirectionalThresholdObjective.xtend
new file mode 100644
index 00000000..376e3d1a
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/DirectionalThresholdObjective.xtend
@@ -0,0 +1,164 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import java.util.Comparator
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.objectives.IObjective
+import org.eclipse.xtend.lib.annotations.Accessors
+import org.eclipse.xtend.lib.annotations.Data
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+
+abstract class ObjectiveThreshold {
+        public static val NO_THRESHOLD = new ObjectiveThreshold {
+                override isHard() {
+                        false
+                }
+
+                override satisfiesThreshold(double cost, Comparator<Double> comparator) {
+                        true
+                }
+
+                override protected postProcessSatisfactoryCost(double cost, ObjectiveKind kind) {
+                        cost
+                }
+
+                override ObjectiveThreshold merge(ObjectiveThreshold other) {
+                        if (other == NO_THRESHOLD) {
+                                NO_THRESHOLD
+                        } else {
+                                throw new IllegalArgumentException("Merged thresholds must have the same type")
+                        }
+                }
+        }
+
+        private new() {
+        }
+
+        def boolean isHard() {
+                true
+        }
+
+        def boolean satisfiesThreshold(double cost, ObjectiveKind kind) {
+                satisfiesThreshold(cost, kind.comparator)
+        }
+
+        def boolean satisfiesThreshold(double cost, Comparator<Double> comparator)
+
+        def double postProcessCost(double cost, ObjectiveKind kind) {
+                if (satisfiesThreshold(cost, kind)) {
+                        postProcessSatisfactoryCost(cost, kind)
+                } else {
+                        cost
+                }
+        }
+
+        protected def double postProcessSatisfactoryCost(double cost, ObjectiveKind kind)
+
+        def ObjectiveThreshold merge(ObjectiveThreshold other)
+
+        @Data
+        static class Exclusive extends ObjectiveThreshold {
+                static val EPSILON = 0.1
+
+                val double threshold
+                val boolean clampToThreshold
+
+                @FinalFieldsConstructor
+                new() {
+                }
+
+                new(double threshold) {
+                        this(threshold, true)
+                }
+
+                override satisfiesThreshold(double cost, Comparator<Double> comparator) {
+                        comparator.compare(threshold, cost) < 0
+                }
+
+                override protected postProcessSatisfactoryCost(double cost, ObjectiveKind kind) {
+                        if (clampToThreshold) {
+                                threshold + Math.signum(kind.satisfiedValue) * EPSILON
+                        } else {
+                                cost
+                        }
+                }
+
+                override ObjectiveThreshold merge(ObjectiveThreshold other) {
+                        if (other instanceof Exclusive) {
+                                new Exclusive(threshold + other.threshold)
+                        } else {
+                                throw new IllegalArgumentException("Merged thresholds must have the same type")
+                        }
+                }
+        }
+
+        @Data
+        static class Inclusive extends ObjectiveThreshold {
+                val double threshold
+                val boolean clampToThreshold
+
+                @FinalFieldsConstructor
+                new() {
+                }
+
+                new(double threshold) {
+                        this(threshold, true)
+                }
+
+                override satisfiesThreshold(double cost, Comparator<Double> comparator) {
+                        comparator.compare(threshold, cost) <= 0
+                }
+
+                override protected postProcessSatisfactoryCost(double cost, ObjectiveKind kind) {
+                        if (clampToThreshold) {
+                                threshold
+                        } else {
+                                cost
+                        }
+                }
+                
+                override ObjectiveThreshold merge(ObjectiveThreshold other) {
+                        if (other instanceof Inclusive) {
+                                new Inclusive(threshold + other.threshold)
+                        } else {
+                                throw new IllegalArgumentException("Merged thresholds must have the same type")
+                        }
+                }
+        }
+}
+
+abstract class DirectionalThresholdObjective implements IObjective {
+        @Accessors val String name
+        @Accessors ObjectiveKind kind
+        @Accessors ObjectiveThreshold threshold
+        @Accessors int level
+
+        protected new(String name, ObjectiveKind kind, ObjectiveThreshold threshold, int level) {
+                this.name = name
+                this.kind = kind
+                this.threshold = threshold
+                this.level = level
+        }
+
+        override isHardObjective() {
+                threshold.hard
+        }
+
+        override satisifiesHardObjective(Double fitness) {
+                threshold.satisfiesThreshold(fitness, comparator)
+        }
+
+        override getComparator() {
+                kind.comparator
+        }
+
+        override setComparator(Comparator<Double> comparator) {
+                kind = ObjectiveKind.fromComparator(comparator)
+        }
+
+        override getFitness(ThreadContext context) {
+                val fitness = getRawFitness(context)
+                threshold.postProcessCost(fitness, kind)
+        }
+
+        protected def double getRawFitness(ThreadContext context)
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IObjectiveBoundsProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IObjectiveBoundsProvider.xtend
new file mode 100644
index 00000000..3c4d36a5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IObjectiveBoundsProvider.xtend
@@ -0,0 +1,8 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.Bounds
+import org.eclipse.viatra.dse.objectives.IObjective
+
+interface IObjectiveBoundsProvider {
+        def void computeRequiredBounds(IObjective objective, Bounds bounds)
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IThreeValuedObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IThreeValuedObjective.xtend
new file mode 100644
index 00000000..4a870a3e
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/IThreeValuedObjective.xtend
@@ -0,0 +1,10 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.dse.objectives.IObjective
+
+interface IThreeValuedObjective extends IObjective {
+        def Double getWorstPossibleFitness(ThreadContext threadContext)
+        
+        def Double getBestPossibleFitness(ThreadContext threadContext)
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/MatchCostObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/MatchCostObjective.xtend
new file mode 100644
index 00000000..a0c6a2c1
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/MatchCostObjective.xtend
@@ -0,0 +1,52 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import com.google.common.collect.ImmutableList
+import java.util.Collection
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+import org.eclipse.xtend.lib.annotations.Data
+
+@Data
+class MatchCostElement {
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> querySpecification
+        val double weight
+}
+
+class MatchCostObjective extends DirectionalThresholdObjective {
+        val Collection<MatchCostElement> costElements
+        Collection<CostElementMatcher> matchers
+
+        new(String name, Collection<MatchCostElement> costElements, ObjectiveKind kind, ObjectiveThreshold threshold,
+                int level) {
+                super(name, kind, threshold, level)
+                this.costElements = costElements
+        }
+
+        override createNew() {
+                new MatchCostObjective(name, costElements, kind, threshold, level)
+        }
+
+        override init(ThreadContext context) {
+                val queryEngine = context.queryEngine
+                matchers = ImmutableList.copyOf(costElements.map [
+                        val matcher = querySpecification.getMatcher(queryEngine)
+                        new CostElementMatcher(matcher, weight)
+                ])
+        }
+
+        override protected getRawFitness(ThreadContext context) {
+                var double cost = 0
+                for (it : matchers) {
+                        cost += weight * matcher.countMatches
+                }
+                cost
+        }
+
+        @Data
+        private static class CostElementMatcher {
+                val ViatraQueryMatcher<? extends IPatternMatch> matcher
+                val double weight
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ObjectiveKind.java b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ObjectiveKind.java
new file mode 100644
index 00000000..cbbaaafd
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ObjectiveKind.java
@@ -0,0 +1,60 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization;
+
+import java.util.Comparator;
+
+import org.eclipse.viatra.dse.objectives.Comparators;
+
+public enum ObjectiveKind {
+        LOWER_IS_BETTER {
+
+                @Override
+                public Comparator<Double> getComparator() {
+                        return Comparators.LOWER_IS_BETTER;
+                }
+
+                @Override
+                public double getInvalidValue() {
+                        return Double.POSITIVE_INFINITY;
+                }
+
+                @Override
+                public double getSatisfiedValue() {
+                        return Double.NEGATIVE_INFINITY;
+                }
+
+        },
+        HIGHER_IS_BETTER {
+
+                @Override
+                public Comparator<Double> getComparator() {
+                        return Comparators.HIGHER_IS_BETTER;
+                }
+
+                @Override
+                public double getInvalidValue() {
+                        return Double.NEGATIVE_INFINITY;
+                }
+
+                @Override
+                public double getSatisfiedValue() {
+                        return Double.POSITIVE_INFINITY;
+                }
+
+        };
+
+        public abstract Comparator<Double> getComparator();
+
+        public abstract double getInvalidValue();
+
+        public abstract double getSatisfiedValue();
+
+        public static ObjectiveKind fromComparator(Comparator<Double> comparator) {
+                if (Comparators.LOWER_IS_BETTER.equals(comparator)) {
+                        return ObjectiveKind.LOWER_IS_BETTER;
+                } else if (Comparators.HIGHER_IS_BETTER.equals(comparator)) {
+                        return ObjectiveKind.HIGHER_IS_BETTER;
+                } else {
+                        throw new IllegalStateException("Only LOWER_IS_BETTER and HIGHER_IS_BETTER comparators are supported.");
+                }
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/QueryBasedObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/QueryBasedObjective.xtend
new file mode 100644
index 00000000..d355f5be
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/QueryBasedObjective.xtend
@@ -0,0 +1,48 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.viatra.query.runtime.api.IPatternMatch
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification
+import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
+
+class QueryBasedObjective extends DirectionalThresholdObjective {
+        val IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> querySpecification
+        ViatraQueryMatcher<? extends IPatternMatch> matcher
+
+        new(IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>> querySpecification,
+                ObjectiveKind kind, ObjectiveThreshold threshold, int level) {
+                super(querySpecification.simpleName + " objective", kind, threshold, level)
+                if (querySpecification.parameters.size != 1) {
+                        throw new IllegalArgumentException("Objective query must have a single parameter")
+                }
+                this.querySpecification = querySpecification
+        }
+
+        override createNew() {
+                new QueryBasedObjective(querySpecification, kind, threshold, level)
+        }
+
+        override init(ThreadContext context) {
+                matcher = querySpecification.getMatcher(context.queryEngine)
+        }
+
+        override protected getRawFitness(ThreadContext context) {
+                val iterator = matcher.allMatches.iterator
+                if (!iterator.hasNext) {
+                        return invalidValue
+                }
+                val value = iterator.next.get(0)
+                if (iterator.hasNext) {
+                        throw new IllegalStateException("Multiple matches for objective query")
+                }
+                if (value instanceof Number) {
+                        value.doubleValue
+                } else {
+                        throw new IllegalStateException("Objective value is not an instance of Number")
+                }
+        }
+
+        private def getInvalidValue() {
+                kind.invalidValue
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjective.xtend
new file mode 100644
index 00000000..9b1a7e9f
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjective.xtend
@@ -0,0 +1,80 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.BoundSaturationListener
+import java.util.Map
+import org.eclipse.viatra.dse.base.ThreadContext
+import org.eclipse.xtend.lib.annotations.Accessors
+
+class ThreeValuedCostObjective extends AbstractThreeValuedObjective implements BoundSaturationListener {
+        @Accessors val Map<String, CostElementMatchers> matchers
+        double lowerBoundHint = Double.NEGATIVE_INFINITY
+        double upperBoundHint = Double.POSITIVE_INFINITY
+
+        new(String name, Map<String, CostElementMatchers> matchers, ObjectiveKind kind, ObjectiveThreshold threshold,
+                int level) {
+                super(name, kind, threshold, level)
+                this.matchers = matchers
+        }
+
+        override createNew() {
+                // new ThreeValuedCostObjective(name, matchers, kind, threshold, level)
+                throw new UnsupportedOperationException("ThreeValuedCostObjective can only be used from a single thread")
+        }
+
+        override init(ThreadContext context) {
+        }
+
+        override getRawFitness(ThreadContext context) {
+                var double cost = 0
+                for (matcher : matchers.values) {
+                        cost += matcher.weight * matcher.currentNumberOfMatches
+                }
+                cost
+        }
+
+        override getLowestPossibleFitness(ThreadContext threadContext) {
+                var double cost = 0
+                for (matcher : matchers.values) {
+                        if (matcher.weight >= 0) {
+                                cost += matcher.weight * matcher.minimumNumberOfMatches
+                        } else {
+                                cost += matcher.weight * matcher.maximumNumberOfMatches
+                        }
+                }
+                val boundWithHint = Math.max(lowerBoundHint, cost)
+                if (boundWithHint > upperBoundHint) {
+                        throw new IllegalStateException("Inconsistent cost bounds")
+                }
+                boundWithHint
+        }
+
+        override getHighestPossibleFitness(ThreadContext threadContext) {
+                var double cost = 0
+                for (matcher : matchers.values) {
+                        if (matcher.weight <= 0) {
+                                cost += matcher.weight * matcher.minimumNumberOfMatches
+                        } else {
+                                cost += matcher.weight * matcher.maximumNumberOfMatches
+                        }
+                }
+                val boundWithHint = Math.min(upperBoundHint, cost)
+                if (boundWithHint < lowerBoundHint) {
+                        throw new IllegalStateException("Inconsistent cost bounds")
+                }
+                boundWithHint
+        }
+
+        override boundsSaturated(Integer lower, Integer upper) {
+                lowerBoundHint = if (lower === null) {
+                        Double.NEGATIVE_INFINITY
+                } else {
+                        lower
+                }
+                upperBoundHint = if (upper === null) {
+                        Double.POSITIVE_INFINITY
+                } else {
+                        upper
+                }
+                println('''Bounds saturated: «lower»..«upper»''')
+        }
+}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjectiveProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjectiveProvider.xtend
new file mode 100644
index 00000000..c2750acd
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/optimization/ThreeValuedCostObjectiveProvider.xtend
@@ -0,0 +1,205 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.optimization
+
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.ImmutableMap
+import com.google.common.collect.Lists
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.StringTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeReference
+import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransfomedViatraQuery
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedronExtensionOperator
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.ModalPatternQueries
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialBooleanInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialIntegerInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRealInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialStringInterpretation
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.Scope
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.CostObjectiveConfiguration
+import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.CostObjectiveElementConfiguration
+import java.util.Collection
+import java.util.Map
+import org.eclipse.viatra.dse.objectives.IObjective
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine
+import org.eclipse.xtend.lib.annotations.Data
+
+@Data
+class ThreeValuedCostObjectiveProviderResult {
+        val Collection<IObjective> objectives
+        val Collection<CostObjectiveHint> hints
+        val Collection<PolyhedronExtensionOperator> extensionOperators
+        val IObjective[][] leveledExtremalObjectives
+        val boolean optimizationProblem
+}
+
+class ThreeValuedCostObjectiveProvider {
+        static val COST_OBJECTIVE_LEVEL = 3
+
+        val ViatraQueryEngine queryEngine
+        val Map<String, ModalPatternQueries> modalRelationQueries
+        val Map<String, Relation> qualifiedNameToRelationMap
+        val ParameterScopeBound defaultBounds
+        val ParameterScopeBound booleanBounds
+        val ParameterScopeBound integerBounds
+        val ParameterScopeBound realBounds
+        val ParameterScopeBound stringBounds
+        val Map<TypeDeclaration, ParameterScopeBound> typeDeclarationToBoundsMap
+
+        new(ViatraQueryEngine queryEngine, PartialInterpretation interpretation,
+                Map<String, ModalPatternQueries> modalRelationQueries) {
+                this.queryEngine = queryEngine
+                this.modalRelationQueries = modalRelationQueries
+                qualifiedNameToRelationMap = ImmutableMap.copyOf(
+                        interpretation.problem.annotations.filter(TransfomedViatraQuery).
+                                toMap([patternFullyQualifiedName], [target]))
+                defaultBounds = new PartialInterpretationBasedParameterScopeBound(interpretation)
+                var ParameterScopeBound booleanBounds = null
+                var ParameterScopeBound integerBounds = null
+                var ParameterScopeBound realBounds = null
+                var ParameterScopeBound stringBounds = null
+                val typeDeclarationToBoundsMapBuilder = ImmutableMap.builder
+                for (scope : interpretation.scopes) {
+                        val bounds = new ScopeBasedParameterScopeBound(scope)
+                        switch (typeInterpretation : scope.targetTypeInterpretation) {
+                                PartialBooleanInterpretation:
+                                        if (booleanBounds === null) {
+                                                booleanBounds = bounds
+                                        } else {
+                                                throw new IllegalStateException("Duplicate partial boolean interpretation")
+                                        }
+                                PartialIntegerInterpretation:
+                                        if (integerBounds === null) {
+                                                integerBounds = bounds
+                                        } else {
+                                                throw new IllegalStateException("Duplicate partial integer interpretation")
+                                        }
+                                PartialRealInterpretation:
+                                        if (realBounds === null) {
+                                                realBounds = bounds
+                                        } else {
+                                                throw new IllegalStateException("Duplicate partial real interpretation")
+                                        }
+                                PartialStringInterpretation:
+                                        if (stringBounds === null) {
+                                                stringBounds = bounds
+                                        } else {
+                                                throw new IllegalStateException("Duplicate partial string interpretation")
+                                        }
+                                PartialComplexTypeInterpretation:
+                                        typeDeclarationToBoundsMapBuilder.put(typeInterpretation.interpretationOf, bounds)
+                        }
+                }
+                this.booleanBounds = booleanBounds ?: defaultBounds
+                this.integerBounds = integerBounds ?: defaultBounds
+                this.realBounds = realBounds ?: defaultBounds
+                this.stringBounds = stringBounds ?: defaultBounds
+                typeDeclarationToBoundsMap = typeDeclarationToBoundsMapBuilder.build
+        }
+
+        def getCostObjectives(Collection<CostObjectiveConfiguration> costObjectives) {
+                val objectives = ImmutableList.<IObjective>builder
+                val hints = ImmutableList.<CostObjectiveHint>builder
+                val extensionOperators = ImmutableList.<PolyhedronExtensionOperator>builder
+                val extremalObjectives = Lists.newArrayListWithExpectedSize(costObjectives.size)
+                for (entry : costObjectives.indexed) {
+                        val objectiveName = '''costObjective«entry.key»'''
+                        val objectiveConfig = entry.value
+                        val costObjective = transformCostObjective(objectiveConfig, objectiveName)
+                        objectives.add(costObjective)
+                        if (objectiveConfig.findExtremum) {
+                                extremalObjectives += costObjective
+                        }
+                        val hint = objectiveConfig.hint
+                        if (hint !== null) {
+                                hints.add(hint)
+                                hint.objective = costObjective
+                                val extensionOperator = hint.createPolyhedronExtensionOperator(costObjective.matchers)
+                                if (extensionOperator !== null) {
+                                        extensionOperators.add(extensionOperator)
+                                }
+                        }
+                }
+                new ThreeValuedCostObjectiveProviderResult(
+                        objectives.build,
+                        hints.build,
+                        extensionOperators.build,
+                        newArrayList(extremalObjectives),
+                        !extremalObjectives.empty
+                )
+        }
+
+        private def transformCostObjective(CostObjectiveConfiguration configuration, String name) {
+                val costElements = ImmutableMap.copyOf(configuration.elements.toMap([patternQualifiedName], [
+                        transformCostElement
+                ]))
+                new ThreeValuedCostObjective(name, costElements, configuration.kind, configuration.threshold,
+                        COST_OBJECTIVE_LEVEL)
+        }
+
+        private def transformCostElement(CostObjectiveElementConfiguration elementConfig) {
+                val relationName = elementConfig.patternQualifiedName
+                val modalQueries = modalRelationQueries.get(relationName)
+                if (modalQueries === null) {
+                        throw new IllegalArgumentException("Unknown relation queries: " + relationName)
+                }
+                val relation = qualifiedNameToRelationMap.get(relationName)
+                if (relation === null) {
+                        throw new IllegalArgumentException("Unknown transformed relation: " + relationName)
+                }
+                val parameterBounds = ImmutableList.copyOf(relation.parameters.map[parameterBound])
+                new CostElementMatchers(
+                        queryEngine.getMatcher(modalQueries.currentQuery),
+                        queryEngine.getMatcher(modalQueries.mayQuery),
+                        queryEngine.getMatcher(modalQueries.mustQuery),
+                        parameterBounds,
+                        elementConfig.weight
+                )
+        }
+
+        private def getParameterBound(TypeReference typeReference) {
+                switch (typeReference) {
+                        BoolTypeReference: booleanBounds
+                        IntTypeReference: integerBounds
+                        RealTypeReference: realBounds
+                        StringTypeReference: stringBounds
+                        ComplexTypeReference: typeDeclarationToBoundsMap.getOrDefault(typeReference.referred, defaultBounds)
+                }
+        }
+
+        private static abstract class AbstractParameterScopeBound implements ParameterScopeBound {
+                override getUpperBound() {
+                        val rawValue = rawUpperBound
+                        if (rawValue < 0) {
+                                Double.POSITIVE_INFINITY
+                        } else {
+                                rawValue
+                        }
+                }
+
+                protected def int getRawUpperBound()
+        }
+
+        @Data
+        private static class ScopeBasedParameterScopeBound extends AbstractParameterScopeBound {
+                val Scope scope
+
+                override protected getRawUpperBound() {
+                        scope.maxNewElements
+                }
+        }
+
+        @Data
+        private static class PartialInterpretationBasedParameterScopeBound extends AbstractParameterScopeBound {
+                val PartialInterpretation interpretation
+
+                override protected getRawUpperBound() {
+                        interpretation.maxNewElements
+                }
+        }
+}