feat: declarative DSE rules and model refinement

34 files changed, 988 insertions, 82 deletions

diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationAdapter.java
index 37448309..d326f1dd 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationAdapter.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationAdapter.java
@@ -7,25 +7,22 @@ package tools.refinery.store.dse.transition;
 
 import tools.refinery.store.adapter.ModelAdapter;
 import tools.refinery.store.dse.transition.internal.DesignSpaceExplorationBuilderImpl;
-import tools.refinery.store.map.Version;
-import tools.refinery.store.tuple.Tuple;
-import tools.refinery.store.tuple.Tuple1;
 
-import java.util.Collection;
 import java.util.List;
 
 public interface DesignSpaceExplorationAdapter extends ModelAdapter {
-
-
-
         @Override
         DesignSpaceExplorationStoreAdapter getStoreAdapter();
 
         static DesignSpaceExplorationBuilder builder() {
                 return new DesignSpaceExplorationBuilderImpl();
         }
+
         List<Transformation> getTransformations();
+
         boolean checkAccept();
+
         boolean checkExclude();
+
         ObjectiveValue getObjectiveValue();
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/AndCriterion.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/AndCriterion.java
new file mode 100644
index 00000000..0ad2b7a4
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/AndCriterion.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.literal.Reduction;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public final class AndCriterion extends CompositeCriterion {
+        AndCriterion(Collection<? extends Criterion> criteria) {
+                super(criteria);
+        }
+
+        @Override
+        public Reduction getReduction(ModelStore store) {
+                for (var criterion : getCriteria()) {
+                        var reduction = criterion.getReduction(store);
+                        if (reduction == Reduction.ALWAYS_FALSE) {
+                                return Reduction.ALWAYS_FALSE;
+                        } else if (reduction == Reduction.NOT_REDUCIBLE) {
+                                return Reduction.NOT_REDUCIBLE;
+                        }
+                }
+                return Reduction.ALWAYS_TRUE;
+        }
+
+        @Override
+        public CriterionCalculator createCalculator(Model model) {
+                var calculators = new ArrayList<CriterionCalculator>();
+                for (var criterion : getCriteria()) {
+                        var reduction = criterion.getReduction(model.getStore());
+                        if (reduction == Reduction.ALWAYS_FALSE) {
+                                return () -> false;
+                        } else if (reduction == Reduction.NOT_REDUCIBLE) {
+                                calculators.add(criterion.createCalculator(model));
+                        }
+                }
+                return () -> {
+                        for (var calculator : calculators) {
+                                if (!calculator.isSatisfied()) {
+                                        return false;
+                                }
+                        }
+                        return true;
+                };
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CompositeCriterion.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CompositeCriterion.java
new file mode 100644
index 00000000..5746cc7e
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CompositeCriterion.java
@@ -0,0 +1,43 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.query.literal.Reduction;
+
+import java.util.*;
+
+public abstract sealed class CompositeCriterion implements Criterion permits AndCriterion, OrCriterion {
+        private final List<Criterion> criteria;
+
+        protected CompositeCriterion(Collection<? extends Criterion> criteria) {
+                var deDuplicatedCriteria = new LinkedHashSet<Criterion>();
+                for (var criterion : criteria) {
+                        if (criterion.getClass() == this.getClass()) {
+                                var childCriteria = ((CompositeCriterion) criterion).getCriteria();
+                                deDuplicatedCriteria.addAll(childCriteria);
+                        } else {
+                                deDuplicatedCriteria.add(criterion);
+                        }
+                }
+                this.criteria = List.copyOf(deDuplicatedCriteria);
+        }
+
+        public List<Criterion> getCriteria() {
+                return criteria;
+        }
+
+        @Override
+        public abstract Reduction getReduction(ModelStore store);
+
+        @Override
+        public void configure(ModelStoreBuilder storeBuilder) {
+                for (var criterion : criteria) {
+                        criterion.configure(storeBuilder);
+                }
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CompositeObjective.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CompositeObjective.java
new file mode 100644
index 00000000..192a824b
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CompositeObjective.java
@@ -0,0 +1,69 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreBuilder;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+public class CompositeObjective implements Objective {
+        private final List<Objective> objectives;
+
+        CompositeObjective(Collection<? extends Objective> objectives) {
+                var unwrappedObjectives = new ArrayList<Objective>();
+                for (var objective : objectives) {
+                        if (objective instanceof CompositeObjective compositeObjective) {
+                                unwrappedObjectives.addAll(compositeObjective.getObjectives());
+                        } else {
+                                unwrappedObjectives.add(objective);
+                        }
+                }
+                this.objectives = Collections.unmodifiableList(unwrappedObjectives);
+        }
+
+        public List<Objective> getObjectives() {
+                return objectives;
+        }
+
+        @Override
+        public boolean isAlwaysZero(ModelStore store) {
+                for (var objective : objectives) {
+                        if (!objective.isAlwaysZero(store)) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+
+        @Override
+        public ObjectiveCalculator createCalculator(Model model) {
+                var calculators = new ArrayList<ObjectiveCalculator>();
+                for (var objective : objectives) {
+                        if (!objective.isAlwaysZero(model.getStore())) {
+                                calculators.add(objective.createCalculator(model));
+                        }
+                }
+                return () -> {
+                        double value = 0;
+                        for (var calculator : calculators) {
+                                value += calculator.getValue();
+                        }
+                        return value;
+                };
+        }
+
+        @Override
+        public void configure(ModelStoreBuilder storeBuilder) {
+                for (var objective : objectives) {
+                        objective.configure(storeBuilder);
+                }
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CountObjective.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CountObjective.java
new file mode 100644
index 00000000..fbd05ded
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CountObjective.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.ModelQueryBuilder;
+import tools.refinery.store.query.ModelQueryStoreAdapter;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.literal.Reduction;
+
+public class CountObjective implements Objective {
+        private final RelationalQuery query;
+        private final double weight;
+
+        public CountObjective(RelationalQuery query) {
+                this(query, 1);
+        }
+
+        public CountObjective(RelationalQuery query, double weight) {
+                this.query = query;
+                this.weight = weight;
+        }
+
+        @Override
+        public boolean isAlwaysZero(ModelStore store) {
+                var queryStore = store.getAdapter(ModelQueryStoreAdapter.class);
+                var canonicalQuery = queryStore.getCanonicalQuery(query);
+                return canonicalQuery.getDnf().getReduction() == Reduction.ALWAYS_FALSE;
+        }
+
+        @Override
+        public ObjectiveCalculator createCalculator(Model model) {
+                var resultSet = model.getAdapter(ModelQueryAdapter.class).getResultSet(query);
+                return () -> resultSet.size() * weight;
+        }
+
+        @Override
+        public void configure(ModelStoreBuilder storeBuilder) {
+                storeBuilder.getAdapter(ModelQueryBuilder.class).query(query);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criteria.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criteria.java
new file mode 100644
index 00000000..0e4ec5c9
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criteria.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.query.dnf.AnyQuery;
+
+import java.util.Collection;
+import java.util.List;
+
+public final class Criteria {
+        private Criteria() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static QueryCriterion whenHasMatch(AnyQuery query) {
+                return new QueryCriterion(query, true);
+        }
+
+        public static QueryCriterion whenNoMatch(AnyQuery query) {
+                return new QueryCriterion(query, false);
+        }
+
+        public static Criterion and(Criterion... criteria) {
+                return and(List.of(criteria));
+        }
+
+        public static Criterion and(Collection<? extends Criterion> criteria) {
+                if (criteria.size() == 1) {
+                        return criteria.iterator().next();
+                }
+                return new AndCriterion(criteria);
+        }
+
+        public static Criterion or(Criterion... criteria) {
+                return or(List.of(criteria));
+        }
+
+        public static Criterion or(Collection<? extends Criterion> criteria) {
+                if (criteria.size() == 1) {
+                        return criteria.iterator().next();
+                }
+                return new OrCriterion(criteria);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criterion.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criterion.java
index 4365cf9c..c827f20e 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criterion.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criterion.java
@@ -6,10 +6,17 @@
 package tools.refinery.store.dse.transition.objectives;
 
 import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.query.literal.Reduction;
 
 public interface Criterion {
         default void configure(ModelStoreBuilder storeBuilder) {
         }
+
+        default Reduction getReduction(ModelStore store) {
+                return Reduction.NOT_REDUCIBLE;
+        }
+
         CriterionCalculator createCalculator(Model model);
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objective.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objective.java
index d2476a2e..49c34d87 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objective.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objective.java
@@ -6,10 +6,18 @@
 package tools.refinery.store.dse.transition.objectives;
 
 import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreBuilder;
 
 public interface Objective {
         default void configure(ModelStoreBuilder storeBuilder) {
         }
+
+        // The name {@code isAlwaysZero} is more straightforward than something like {@code canBeNonZero}.
+        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+        default boolean isAlwaysZero(ModelStore store) {
+                return false;
+        }
+
         ObjectiveCalculator createCalculator(Model model);
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objectives.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objectives.java
new file mode 100644
index 00000000..e552d14c
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objectives.java
@@ -0,0 +1,41 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.query.dnf.FunctionalQuery;
+import tools.refinery.store.query.dnf.RelationalQuery;
+
+import java.util.Collection;
+import java.util.List;
+
+public final class Objectives {
+        private Objectives() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static CountObjective count(RelationalQuery query, double weight) {
+                return new CountObjective(query, weight);
+        }
+
+        public static CountObjective count(RelationalQuery query) {
+                return new CountObjective(query);
+        }
+
+        public static QueryObjective value(FunctionalQuery<? extends Number> query) {
+                return new QueryObjective(query);
+        }
+
+        public static Objective sum(Objective... objectives) {
+                return sum(List.of(objectives));
+        }
+
+        public static Objective sum(Collection<? extends Objective> objectives) {
+                if (objectives.size() == 1) {
+                        return objectives.iterator().next();
+                }
+                return new CompositeObjective(objectives);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/OrCriterion.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/OrCriterion.java
new file mode 100644
index 00000000..7a8d7778
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/OrCriterion.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.literal.Reduction;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public final class OrCriterion extends CompositeCriterion {
+        OrCriterion(Collection<? extends Criterion> criteria) {
+                super(criteria);
+        }
+
+        @Override
+        public Reduction getReduction(ModelStore store) {
+                for (var criterion : getCriteria()) {
+                        var reduction = criterion.getReduction(store);
+                        if (reduction == Reduction.ALWAYS_TRUE) {
+                                return Reduction.ALWAYS_TRUE;
+                        } else if (reduction == Reduction.NOT_REDUCIBLE) {
+                                return Reduction.NOT_REDUCIBLE;
+                        }
+                }
+                return Reduction.ALWAYS_FALSE;
+        }
+
+        @Override
+        public CriterionCalculator createCalculator(Model model) {
+                var calculators = new ArrayList<CriterionCalculator>();
+                for (var criterion : getCriteria()) {
+                        var reduction = criterion.getReduction(model.getStore());
+                        if (reduction == Reduction.ALWAYS_TRUE) {
+                                return () -> true;
+                        } else if (reduction == Reduction.NOT_REDUCIBLE) {
+                                calculators.add(criterion.createCalculator(model));
+                        }
+                }
+                return () -> {
+                        for (var calculator : calculators) {
+                                if (calculator.isSatisfied()) {
+                                        return true;
+                                }
+                        }
+                        return false;
+                };
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryCriteria.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryCriterion.java
index 8d0a56cf..e15e4e41 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryCriteria.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryCriterion.java
@@ -6,30 +6,45 @@
 package tools.refinery.store.dse.transition.objectives;
 
 import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.query.ModelQueryAdapter;
 import tools.refinery.store.query.ModelQueryBuilder;
+import tools.refinery.store.query.ModelQueryStoreAdapter;
 import tools.refinery.store.query.dnf.AnyQuery;
+import tools.refinery.store.query.literal.Reduction;
 
-public class QueryCriteria implements Criterion {
-        protected final boolean acceptIfHasMatch;
+public class QueryCriterion implements Criterion {
+        protected final boolean satisfiedIfHasMatch;
         protected final AnyQuery query;
 
         /**
          * Criteria based on the existence of matches evaluated on the model.
-         * @param query The query evaluated on the model.
-         * @param acceptIfHasMatch If true, the criteria satisfied if the query has any match on the model. Otherwise,
+         *
+         * @param query               The query evaluated on the model.
+         * @param satisfiedIfHasMatch If true, the criteria satisfied if the query has any match on the model. Otherwise,
          *                            the criteria satisfied if the query has no match on the model.
          */
-        public QueryCriteria(AnyQuery query, boolean acceptIfHasMatch) {
+        public QueryCriterion(AnyQuery query, boolean satisfiedIfHasMatch) {
                 this.query = query;
-                this.acceptIfHasMatch = acceptIfHasMatch;
+                this.satisfiedIfHasMatch = satisfiedIfHasMatch;
+        }
+
+        @Override
+        public Reduction getReduction(ModelStore store) {
+                var queryStore = store.getAdapter(ModelQueryStoreAdapter.class);
+                var canonicalQuery = queryStore.getCanonicalQuery(query);
+                var reduction = canonicalQuery.getDnf().getReduction();
+                if (satisfiedIfHasMatch) {
+                        return reduction;
+                }
+                return reduction.negate();
         }
 
         @Override
         public CriterionCalculator createCalculator(Model model) {
                 var resultSet = model.getAdapter(ModelQueryAdapter.class).getResultSet(query);
-                if(acceptIfHasMatch) {
+                if (satisfiedIfHasMatch) {
                         return () -> resultSet.size() > 0;
                 } else {
                         return () -> resultSet.size() == 0;
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryObjective.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryObjective.java
index 9553e0e0..9f4bb536 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryObjective.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryObjective.java
@@ -15,6 +15,10 @@ public class QueryObjective implements Objective {
         protected final FunctionalQuery<? extends Number> objectiveFunction;
 
         public QueryObjective(FunctionalQuery<? extends Number> objectiveFunction) {
+                if (objectiveFunction.arity() != 0) {
+                        throw new IllegalArgumentException("Objective functions must have 0 parameters, got %d instead"
+                                        .formatted(objectiveFunction.arity()));
+                }
                 this.objectiveFunction = objectiveFunction;
         }
 
@@ -23,22 +27,15 @@ public class QueryObjective implements Objective {
                 var resultSet = model.getAdapter(ModelQueryAdapter.class).getResultSet(objectiveFunction);
                 return () -> {
                         var cursor = resultSet.getAll();
-                        boolean hasElement = cursor.move();
-                        if(hasElement) {
-                                double result = cursor.getValue().doubleValue();
-                                if(cursor.move()) {
-                                        throw new IllegalStateException("Query providing the objective function has multiple values!");
-                                }
-                                return result;
-                        } else {
+                        if (!cursor.move()) {
                                 throw new IllegalStateException("Query providing the objective function has no values!");
                         }
+                        return cursor.getValue().doubleValue();
                 };
         }
 
         @Override
         public void configure(ModelStoreBuilder storeBuilder) {
-                Objective.super.configure(storeBuilder);
                 storeBuilder.getAdapter(ModelQueryBuilder.class).query(objectiveFunction);
         }
 }
diff --git a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/LowerTypeScopePropagator.java b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/LowerTypeScopePropagator.java
index b1c421b7..393c4b72 100644
--- a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/LowerTypeScopePropagator.java
+++ b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/LowerTypeScopePropagator.java
@@ -5,43 +5,55 @@
  */
 package tools.refinery.store.reasoning.scope.internal;
 
+import tools.refinery.store.dse.transition.DesignSpaceExplorationBuilder;
+import tools.refinery.store.dse.transition.objectives.Criteria;
+import tools.refinery.store.dse.transition.objectives.Objectives;
+import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.query.dnf.AnyQuery;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.reasoning.ReasoningBuilder;
+import tools.refinery.store.reasoning.literal.CountCandidateLowerBoundLiteral;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 
 import java.util.Collection;
 import java.util.List;
 
+import static tools.refinery.store.query.literal.Literals.check;
+import static tools.refinery.store.query.term.int_.IntTerms.*;
 import static tools.refinery.store.reasoning.literal.PartialLiterals.may;
+import static tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator.MULTI_VIEW;
 
 class LowerTypeScopePropagator extends TypeScopePropagator {
         private final int lowerBound;
 
         private LowerTypeScopePropagator(ScopePropagatorAdapterImpl adapter, int lowerBound, RelationalQuery allQuery,
-                                                                        RelationalQuery multiQuery) {
+                                                                         RelationalQuery multiQuery) {
                 super(adapter, allQuery, multiQuery);
                 this.lowerBound = lowerBound;
         }
 
         @Override
         public void updateBounds() {
-                constraint.setLb(lowerBound - getSingleCount());
+                constraint.setLb((lowerBound - getSingleCount()));
         }
 
-        public static class Factory implements TypeScopePropagator.Factory {
+        public static class Factory extends TypeScopePropagator.Factory {
+                private final PartialRelation type;
                 private final int lowerBound;
                 private final RelationalQuery allMay;
                 private final RelationalQuery multiMay;
 
-                public Factory(RelationalQuery multi, PartialRelation type, int lowerBound) {
+                public Factory(PartialRelation type, int lowerBound) {
+                        this.type = type;
                         this.lowerBound = lowerBound;
                         allMay = Query.of(type.name() + "#may", (builder, instance) -> builder.clause(
                                         may(type.call(instance))
                         ));
                         multiMay = Query.of(type.name() + "#multiMay", (builder, instance) -> builder.clause(
                                         may(type.call(instance)),
-                                        multi.call(instance)
+                                        MULTI_VIEW.call(instance)
                         ));
                 }
 
@@ -51,8 +63,24 @@ class LowerTypeScopePropagator extends TypeScopePropagator {
                 }
 
                 @Override
-                public Collection<AnyQuery> getQueries() {
+                protected Collection<AnyQuery> getQueries() {
                         return List.of(allMay, multiMay);
                 }
+
+                @Override
+                public void configure(ModelStoreBuilder storeBuilder) {
+                        super.configure(storeBuilder);
+
+                        var requiredObjects = Query.of(type.name() + "#required", Integer.class, (builder, output) -> builder
+                                        .clause(Integer.class, currentCount -> List.of(
+                                                        new CountCandidateLowerBoundLiteral(currentCount, type, List.of(Variable.of())),
+                                                        output.assign(sub(currentCount, constant(lowerBound))),
+                                                        check(greater(currentCount, constant(0)))
+                                        )));
+
+                        storeBuilder.getAdapter(ReasoningBuilder.class).objective(Objectives.value(requiredObjects));
+                        storeBuilder.tryGetAdapter(DesignSpaceExplorationBuilder.class).ifPresent(dseBuilder ->
+                                        dseBuilder.accept(Criteria.whenNoMatch(requiredObjects)));
+                }
         }
 }
diff --git a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/ScopePropagatorAdapterImpl.java b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/ScopePropagatorAdapterImpl.java
index c257df6b..99c501ce 100644
--- a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/ScopePropagatorAdapterImpl.java
+++ b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/ScopePropagatorAdapterImpl.java
@@ -85,12 +85,7 @@ class ScopePropagatorAdapterImpl implements ScopePropagatorAdapter {
                 int nodeId = key.get(0);
                 if ((toValue == null || toValue.equals(CardinalityIntervals.ONE))) {
                         if (fromValue != null && !fromValue.equals(CardinalityIntervals.ONE)) {
-                                var variable = variables.get(nodeId);
-                                if (variable == null || !activeVariables.remove(nodeId)) {
-                                        throw new AssertionError("Variable not active: " + nodeId);
-                                }
-                                variable.setBounds(0, 0);
-                                markAsChanged();
+                                removeActiveVariable(toValue, nodeId);
                         }
                         return;
                 }
@@ -115,6 +110,21 @@ class ScopePropagatorAdapterImpl implements ScopePropagatorAdapter {
                 }
         }
 
+        private void removeActiveVariable(CardinalityInterval toValue, int nodeId) {
+                var variable = variables.get(nodeId);
+                if (variable == null || !activeVariables.remove(nodeId)) {
+                        throw new AssertionError("Variable not active: " + nodeId);
+                }
+                if (toValue == null) {
+                        variable.setBounds(0, 0);
+                } else {
+                        // Until queries are flushed and the constraints can be properly updated,
+                        // the variable corresponding to the (previous) multi-object has to stand in for a single object.
+                        variable.setBounds(1, 1);
+                }
+                markAsChanged();
+        }
+
         MPConstraint makeConstraint() {
                 return solver.makeConstraint();
         }
diff --git a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/ScopePropagatorBuilderImpl.java b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/ScopePropagatorBuilderImpl.java
index 11ca7381..531a7440 100644
--- a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/ScopePropagatorBuilderImpl.java
+++ b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/ScopePropagatorBuilderImpl.java
@@ -9,8 +9,6 @@ import com.google.ortools.Loader;
 import tools.refinery.store.adapter.AbstractModelAdapterBuilder;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreBuilder;
-import tools.refinery.store.query.ModelQueryBuilder;
-import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.scope.ScopePropagatorBuilder;
 import tools.refinery.store.reasoning.scope.ScopePropagatorStoreAdapter;
@@ -60,25 +58,22 @@ public class ScopePropagatorBuilderImpl extends AbstractModelAdapterBuilder<Scop
 
         @Override
         protected void doConfigure(ModelStoreBuilder storeBuilder) {
-                var multiQuery = Query.of("MULTI", (builder, instance) -> builder.clause(
-                                new MultiView(countSymbol).call(instance)));
                 typeScopePropagatorFactories = new ArrayList<>(scopes.size());
                 for (var entry : scopes.entrySet()) {
                         var type = entry.getKey();
                         var bounds = entry.getValue();
                         if (bounds.lowerBound() > 0) {
-                                var lowerFactory = new LowerTypeScopePropagator.Factory(multiQuery, type, bounds.lowerBound());
+                                var lowerFactory = new LowerTypeScopePropagator.Factory(type, bounds.lowerBound());
                                 typeScopePropagatorFactories.add(lowerFactory);
                         }
                         if (bounds.upperBound() instanceof FiniteUpperCardinality finiteUpperCardinality) {
-                                var upperFactory = new UpperTypeScopePropagator.Factory(multiQuery, type,
+                                var upperFactory = new UpperTypeScopePropagator.Factory(type,
                                                 finiteUpperCardinality.finiteUpperBound());
                                 typeScopePropagatorFactories.add(upperFactory);
                         }
                 }
-                var queryBuilder = storeBuilder.getAdapter(ModelQueryBuilder.class);
                 for (var factory : typeScopePropagatorFactories) {
-                        queryBuilder.queries(factory.getQueries());
+                        factory.configure(storeBuilder);
                 }
         }
 
diff --git a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/TypeScopePropagator.java b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/TypeScopePropagator.java
index 98f6ed8b..cfb95829 100644
--- a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/TypeScopePropagator.java
+++ b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/TypeScopePropagator.java
@@ -6,7 +6,9 @@
 package tools.refinery.store.reasoning.scope.internal;
 
 import com.google.ortools.linearsolver.MPConstraint;
+import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.ModelQueryBuilder;
 import tools.refinery.store.query.dnf.AnyQuery;
 import tools.refinery.store.query.dnf.RelationalQuery;
 import tools.refinery.store.query.resultset.ResultSet;
@@ -53,9 +55,13 @@ abstract class TypeScopePropagator {
                 adapter.markAsChanged();
         }
 
-        interface Factory {
-                TypeScopePropagator createPropagator(ScopePropagatorAdapterImpl adapter);
+        public abstract static class Factory {
+                public abstract TypeScopePropagator createPropagator(ScopePropagatorAdapterImpl adapter);
 
-                Collection<AnyQuery> getQueries();
+                protected abstract Collection<AnyQuery> getQueries();
+
+                public void configure(ModelStoreBuilder storeBuilder) {
+                        storeBuilder.getAdapter(ModelQueryBuilder.class).queries(getQueries());
+                }
         }
 }
diff --git a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/UpperTypeScopePropagator.java b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/UpperTypeScopePropagator.java
index 9f09ed56..a0be0fb4 100644
--- a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/UpperTypeScopePropagator.java
+++ b/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/UpperTypeScopePropagator.java
@@ -14,6 +14,7 @@ import java.util.Collection;
 import java.util.List;
 
 import static tools.refinery.store.reasoning.literal.PartialLiterals.must;
+import static tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator.MULTI_VIEW;
 
 class UpperTypeScopePropagator extends TypeScopePropagator {
         private final int upperBound;
@@ -29,19 +30,19 @@ class UpperTypeScopePropagator extends TypeScopePropagator {
                 constraint.setUb(upperBound - getSingleCount());
         }
 
-        public static class Factory implements TypeScopePropagator.Factory {
+        public static class Factory extends TypeScopePropagator.Factory {
                 private final int upperBound;
                 private final RelationalQuery allMust;
                 private final RelationalQuery multiMust;
 
-                public Factory(RelationalQuery multi, PartialRelation type, int upperBound) {
+                public Factory(PartialRelation type, int upperBound) {
                         this.upperBound = upperBound;
                         allMust = Query.of(type.name() + "#must", (builder, instance) -> builder.clause(
                                         must(type.call(instance))
                         ));
                         multiMust = Query.of(type.name() + "#multiMust", (builder, instance) -> builder.clause(
                                         must(type.call(instance)),
-                                        multi.call(instance)
+                                        MULTI_VIEW.call(instance)
                         ));
                 }
 
@@ -51,7 +52,7 @@ class UpperTypeScopePropagator extends TypeScopePropagator {
                 }
 
                 @Override
-                public Collection<AnyQuery> getQueries() {
+                protected Collection<AnyQuery> getQueries() {
                         return List.of(allMust, multiMust);
                 }
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java
index 17aec09c..1dda7ac1 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java
@@ -42,6 +42,9 @@ public interface ReasoningAdapter extends ModelAdapter {
         @Nullable
         Tuple1 split(int parentMultiObject);
 
+        @Nullable
+        Tuple1 focus(int parentObject);
+
         boolean cleanup(int nodeToDelete);
 
         static ReasoningBuilder builder() {
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningBuilder.java
index 3d4c672f..79bce33e 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningBuilder.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningBuilder.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.reasoning;
 
 import tools.refinery.store.adapter.ModelAdapterBuilder;
+import tools.refinery.store.dse.transition.objectives.Objective;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.dnf.Dnf;
 import tools.refinery.store.query.dnf.FunctionalQuery;
@@ -35,6 +36,17 @@ public interface ReasoningBuilder extends ModelAdapterBuilder {
 
         ReasoningBuilder initializer(PartialModelInitializer initializer);
 
+        ReasoningBuilder objective(Objective objective);
+
+        default ReasoningBuilder objectives(Objective... objectives) {
+                return objectives(List.of(objectives));
+        }
+
+        default ReasoningBuilder objectives(Collection<Objective> objectives) {
+                objectives.forEach(this::objective);
+                return this;
+        }
+
         <T> Query<T> lift(Modality modality, Concreteness concreteness, Query<T> query);
 
         RelationalQuery lift(Modality modality, Concreteness concreteness, RelationalQuery query);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/actions/FocusActionLiteral.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/actions/FocusActionLiteral.java
new file mode 100644
index 00000000..5a6f22d2
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/actions/FocusActionLiteral.java
@@ -0,0 +1,48 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.actions;
+
+import tools.refinery.store.dse.transition.actions.AbstractActionLiteral;
+import tools.refinery.store.dse.transition.actions.BoundActionLiteral;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+
+import java.util.List;
+
+public class FocusActionLiteral extends AbstractActionLiteral {
+        private final NodeVariable parentNode;
+        private final NodeVariable childNode;
+
+        public FocusActionLiteral(NodeVariable parentNode, NodeVariable childNode) {
+                this.parentNode = parentNode;
+                this.childNode = childNode;
+        }
+
+        public NodeVariable getParentNode() {
+                return parentNode;
+        }
+
+        public NodeVariable getChildNode() {
+                return childNode;
+        }
+
+        @Override
+        public List<NodeVariable> getInputVariables() {
+                return List.of(parentNode);
+        }
+
+        @Override
+        public List<NodeVariable> getOutputVariables() {
+                return List.of(childNode);
+        }
+
+        @Override
+        public BoundActionLiteral bindToModel(Model model) {
+                var reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
+                return tuple -> reasoningAdapter.focus(tuple.get(0));
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/actions/MergeActionLiteral.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/actions/MergeActionLiteral.java
new file mode 100644
index 00000000..8d0d7961
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/actions/MergeActionLiteral.java
@@ -0,0 +1,60 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.actions;
+
+import tools.refinery.store.dse.transition.actions.AbstractActionLiteral;
+import tools.refinery.store.dse.transition.actions.BoundActionLiteral;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.List;
+
+public class MergeActionLiteral<A, C> extends AbstractActionLiteral {
+        private final PartialSymbol<A, C> partialSymbol;
+        private final List<NodeVariable> parameters;
+        private final A value;
+
+        public MergeActionLiteral(PartialSymbol<A, C> partialSymbol, A value, List<NodeVariable> parameters) {
+                if (partialSymbol.arity() != parameters.size()) {
+                        throw new IllegalArgumentException("Expected %d parameters for partial symbol %s, got %d instead"
+                                        .formatted(partialSymbol.arity(), partialSymbol, parameters.size()));
+                }
+                this.partialSymbol = partialSymbol;
+                this.parameters = parameters;
+                this.value = value;
+        }
+
+        public PartialSymbol<A, C> getPartialSymbol() {
+                return partialSymbol;
+        }
+
+        public List<NodeVariable> getParameters() {
+                return parameters;
+        }
+
+        public A getValue() {
+                return value;
+        }
+
+        @Override
+        public List<NodeVariable> getInputVariables() {
+                return getParameters();
+        }
+
+        @Override
+        public List<NodeVariable> getOutputVariables() {
+                return List.of();
+        }
+
+        @Override
+        public BoundActionLiteral bindToModel(Model model) {
+                var refiner = model.getAdapter(ReasoningAdapter.class).getRefiner(partialSymbol);
+                return tuple -> refiner.merge(tuple, value) ? Tuple.of() : null;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/actions/PartialActionLiterals.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/actions/PartialActionLiterals.java
new file mode 100644
index 00000000..990d11e5
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/actions/PartialActionLiterals.java
@@ -0,0 +1,38 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.actions;
+
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.representation.TruthValue;
+
+import java.util.List;
+
+public final class PartialActionLiterals {
+        private PartialActionLiterals() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static <A, C> MergeActionLiteral<A, C> merge(PartialSymbol<A, C> partialSymbol, A value,
+                                                                                                                NodeVariable... parameters) {
+                return new MergeActionLiteral<>(partialSymbol, value, List.of(parameters));
+        }
+
+        public static MergeActionLiteral<TruthValue, Boolean> add(PartialRelation partialRelation,
+                                                                                                                          NodeVariable... parameters) {
+                return merge(partialRelation, TruthValue.TRUE, parameters);
+        }
+
+        public static MergeActionLiteral<TruthValue, Boolean> remove(PartialRelation partialRelation,
+                                                                                                                                 NodeVariable... parameters) {
+                return merge(partialRelation, TruthValue.FALSE, parameters);
+        }
+
+        public static FocusActionLiteral focus(NodeVariable parent, NodeVariable child) {
+                return new FocusActionLiteral(parent, child);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
index 2fa744de..f91fdd07 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
@@ -17,7 +17,10 @@ import tools.refinery.store.reasoning.refinement.PartialInterpretationRefiner;
 import tools.refinery.store.reasoning.refinement.StorageRefiner;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
 import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.cardinality.CardinalityInterval;
+import tools.refinery.store.representation.cardinality.CardinalityIntervals;
 import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.tuple.Tuple1;
 
@@ -32,6 +35,7 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
         private final Map<AnyPartialSymbol, AnyPartialInterpretationRefiner> refiners;
         private final StorageRefiner[] storageRefiners;
         private final Interpretation<Integer> nodeCountInterpretation;
+        private final Interpretation<CardinalityInterval> countInterpretation;
 
         ReasoningAdapterImpl(Model model, ReasoningStoreAdapterImpl storeAdapter) {
                 this.model = model;
@@ -51,6 +55,11 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
                 storageRefiners = storeAdapter.createStorageRefiner(model);
 
                 nodeCountInterpretation = model.getInterpretation(NODE_COUNT_SYMBOL);
+                if (model.getStore().getSymbols().contains(MultiObjectTranslator.COUNT_STORAGE)) {
+                        countInterpretation = model.getInterpretation(MultiObjectTranslator.COUNT_STORAGE);
+                } else {
+                        countInterpretation = null;
+                }
         }
 
         private void createPartialInterpretations() {
@@ -161,6 +170,26 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
         }
 
         @Override
+        public @Nullable Tuple1 focus(int parentObject) {
+                if (countInterpretation == null) {
+                        throw new IllegalStateException("Cannot focus without " + MultiObjectTranslator.class.getSimpleName());
+                }
+                var tuple = Tuple.of(parentObject);
+                var count = countInterpretation.get(tuple);
+                if (CardinalityIntervals.ONE.equals(count)) {
+                        return tuple;
+                }
+                if (CardinalityIntervals.LONE.equals(count)) {
+                        countInterpretation.put(tuple, CardinalityIntervals.ONE);
+                        return tuple;
+                }
+                if (CardinalityIntervals.NONE.equals(count)) {
+                        return null;
+                }
+                return split(parentObject);
+        }
+
+        @Override
         public boolean cleanup(int nodeToDelete) {
                 // Avoid creating an iterator object.
                 //noinspection ForLoopReplaceableByForEach
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningBuilderImpl.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningBuilderImpl.java
index b4971d2c..d2cd2eb0 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningBuilderImpl.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningBuilderImpl.java
@@ -6,6 +6,9 @@
 package tools.refinery.store.reasoning.internal;
 
 import tools.refinery.store.adapter.AbstractModelAdapterBuilder;
+import tools.refinery.store.dse.transition.DesignSpaceExplorationBuilder;
+import tools.refinery.store.dse.transition.objectives.Objective;
+import tools.refinery.store.dse.transition.objectives.Objectives;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.query.ModelQueryBuilder;
@@ -36,11 +39,13 @@ public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder<ReasoningS
         private final PartialQueryRewriter queryRewriter = new PartialQueryRewriter(lifter);
         private Set<Concreteness> requiredInterpretations = Set.of(Concreteness.values());
         private final Map<AnyPartialSymbol, AnyPartialSymbolTranslator> translators = new LinkedHashMap<>();
-        private final Map<AnyPartialSymbol, PartialInterpretation.Factory<?, ?>> symbolInterpreters = new LinkedHashMap<>();
+        private final Map<AnyPartialSymbol, PartialInterpretation.Factory<?, ?>> symbolInterpreters =
+                        new LinkedHashMap<>();
         private final Map<AnyPartialSymbol, PartialInterpretationRefiner.Factory<?, ?>> symbolRefiners =
                         new LinkedHashMap<>();
         private final Map<AnySymbol, StorageRefiner.Factory<?>> registeredStorageRefiners = new LinkedHashMap<>();
         private final List<PartialModelInitializer> initializers = new ArrayList<>();
+        private final List<Objective> objectives = new ArrayList<>();
 
         @Override
         public ReasoningBuilder requiredInterpretations(Collection<Concreteness> requiredInterpretations) {
@@ -75,6 +80,13 @@ public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder<ReasoningS
         }
 
         @Override
+        public ReasoningBuilder objective(Objective objective) {
+                checkNotConfigured();
+                objectives.add(objective);
+                return this;
+        }
+
+        @Override
         public <T> Query<T> lift(Modality modality, Concreteness concreteness, Query<T> query) {
                 return lifter.lift(modality, concreteness, query);
         }
@@ -109,6 +121,10 @@ public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder<ReasoningS
                 storeBuilder.symbols(registeredStorageRefiners.keySet());
                 var queryBuilder = storeBuilder.getAdapter(ModelQueryBuilder.class);
                 queryBuilder.rewriter(queryRewriter);
+                if (!objectives.isEmpty()) {
+                        storeBuilder.tryGetAdapter(DesignSpaceExplorationBuilder.class)
+                                        .ifPresent(dseBuilder -> dseBuilder.objective(Objectives.sum(objectives)));
+                }
         }
 
         private void doConfigure(ModelStoreBuilder storeBuilder, PartialRelationTranslator relationConfiguration) {
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialRelationTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialRelationTranslator.java
index 4600d5a4..c2039afc 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialRelationTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialRelationTranslator.java
@@ -5,14 +5,21 @@
  */
 package tools.refinery.store.reasoning.translator;
 
+import tools.refinery.store.dse.transition.Rule;
+import tools.refinery.store.dse.transition.objectives.Criteria;
+import tools.refinery.store.dse.transition.objectives.Criterion;
+import tools.refinery.store.dse.transition.objectives.Objective;
+import tools.refinery.store.dse.transition.objectives.Objectives;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.query.Constraint;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.dnf.QueryBuilder;
 import tools.refinery.store.query.dnf.RelationalQuery;
-import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.NodeVariable;
 import tools.refinery.store.query.view.MayView;
 import tools.refinery.store.query.view.MustView;
+import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.ReasoningBuilder;
 import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
 import tools.refinery.store.reasoning.interpretation.PartialRelationRewriter;
@@ -21,6 +28,7 @@ import tools.refinery.store.reasoning.interpretation.QueryBasedRelationRewriter;
 import tools.refinery.store.reasoning.lifting.DnfLifter;
 import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.literal.Modality;
+import tools.refinery.store.reasoning.literal.PartialLiterals;
 import tools.refinery.store.reasoning.refinement.ConcreteSymbolRefiner;
 import tools.refinery.store.reasoning.refinement.PartialInterpretationRefiner;
 import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
@@ -30,8 +38,11 @@ import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.representation.TruthValue;
 
+import java.util.ArrayList;
 import java.util.function.BiConsumer;
 
+import static tools.refinery.store.query.literal.Literals.not;
+
 @SuppressWarnings("UnusedReturnValue")
 public final class PartialRelationTranslator extends PartialSymbolTranslator<TruthValue, Boolean> {
         private final PartialRelation partialRelation;
@@ -94,6 +105,30 @@ public final class PartialRelationTranslator extends PartialSymbolTranslator<Tru
                 return this;
         }
 
+        @Override
+        public PartialRelationTranslator decision(Rule decisionRule) {
+                super.decision(decisionRule);
+                return this;
+        }
+
+        @Override
+        public PartialRelationTranslator accept(Criterion acceptanceCriterion) {
+                super.accept(acceptanceCriterion);
+                return this;
+        }
+
+        @Override
+        public PartialRelationTranslator exclude(Criterion exclusionCriterion) {
+                super.exclude(exclusionCriterion);
+                return this;
+        }
+
+        @Override
+        public PartialRelationTranslator objective(Objective objective) {
+                super.objective(objective);
+                return this;
+        }
+
         public PartialRelationTranslator query(RelationalQuery query) {
                 checkNotConfigured();
                 if (this.query != null) {
@@ -170,6 +205,8 @@ public final class PartialRelationTranslator extends PartialSymbolTranslator<Tru
                 createFallbackRewriter();
                 createFallbackInterpretation();
                 createFallbackRefiner();
+                createFallbackExclude();
+                createFallbackObjective();
                 super.doConfigure(storeBuilder);
         }
 
@@ -179,10 +216,10 @@ public final class PartialRelationTranslator extends PartialSymbolTranslator<Tru
                 }
         }
 
-        private RelationalQuery createQuery(String name, BiConsumer<QueryBuilder, Variable[]> callback) {
+        private RelationalQuery createQuery(String name, BiConsumer<QueryBuilder, NodeVariable[]> callback) {
                 int arity = partialRelation.arity();
                 var queryBuilder = Query.builder(name);
-                var parameters = new Variable[arity];
+                var parameters = new NodeVariable[arity];
                 for (int i = 0; i < arity; i++) {
                         parameters[i] = queryBuilder.parameter("p" + 1);
                 }
@@ -293,6 +330,55 @@ public final class PartialRelationTranslator extends PartialSymbolTranslator<Tru
                 }
         }
 
+        private void createFallbackExclude() {
+                if (excludeWasSet) {
+                        return;
+                }
+                var excludeQuery = createQuery("exclude", (builder, parameters) -> {
+                        var literals = new ArrayList<Literal>(parameters.length + 2);
+                        literals.add(PartialLiterals.must(partialRelation.call(parameters)));
+                        literals.add(not(PartialLiterals.may(partialRelation.call(parameters))));
+                        for (var parameter : parameters) {
+                                literals.add(PartialLiterals.must(ReasoningAdapter.EXISTS_SYMBOL.call(parameter)));
+                        }
+                        builder.clause(literals);
+                });
+                exclude = Criteria.whenHasMatch(excludeQuery);
+        }
+
+        private void createFallbackObjective() {
+                if (acceptWasSet && objectiveWasSet) {
+                        return;
+                }
+                var invalidCandidate = createQuery("invalidCandidate", (builder, parameters) -> builder
+                                .clause(
+                                                PartialLiterals.candidateMust(partialRelation.call(parameters)),
+                                                not(PartialLiterals.candidateMay(partialRelation.call(parameters)))
+                                )
+                                .clause(
+                                                PartialLiterals.candidateMust(partialRelation.call(parameters)),
+                                                not(PartialLiterals.may(partialRelation.call(parameters)))
+                                )
+                                .clause(
+                                                PartialLiterals.must(partialRelation.call(parameters)),
+                                                not(PartialLiterals.candidateMay(partialRelation.call(parameters)))
+                                ));
+                var reject = createQuery("reject", (builder, parameters) -> {
+                        var literals = new ArrayList<Literal>(parameters.length + 1);
+                        literals.add(invalidCandidate.call(parameters));
+                        for (var parameter : parameters) {
+                                literals.add(PartialLiterals.candidateMust(ReasoningAdapter.EXISTS_SYMBOL.call(parameter)));
+                        }
+                        builder.clause(literals);
+                });
+                if (!acceptWasSet) {
+                        accept = Criteria.whenNoMatch(reject);
+                }
+                if (!objectiveWasSet) {
+                        objective = Objectives.count(reject);
+                }
+        }
+
         public PartialRelationRewriter getRewriter() {
                 checkConfigured();
                 return rewriter;
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialSymbolTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialSymbolTranslator.java
index e7e26cb2..6cdb287d 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialSymbolTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialSymbolTranslator.java
@@ -5,10 +5,14 @@
  */
 package tools.refinery.store.reasoning.translator;
 
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.dse.transition.DesignSpaceExplorationBuilder;
+import tools.refinery.store.dse.transition.Rule;
+import tools.refinery.store.dse.transition.objectives.Criterion;
+import tools.refinery.store.dse.transition.objectives.Objective;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.reasoning.ReasoningBuilder;
 import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
-import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.refinement.PartialInterpretationRefiner;
 import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
 import tools.refinery.store.reasoning.refinement.StorageRefiner;
@@ -17,7 +21,8 @@ import tools.refinery.store.reasoning.seed.SeedInitializer;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
 
-import java.util.Set;
+import java.util.ArrayList;
+import java.util.List;
 
 @SuppressWarnings("UnusedReturnValue")
 public abstract sealed class PartialSymbolTranslator<A, C> implements AnyPartialSymbolTranslator
@@ -29,6 +34,13 @@ public abstract sealed class PartialSymbolTranslator<A, C> implements AnyPartial
         protected StorageRefiner.Factory<?> storageRefiner;
         protected PartialInterpretation.Factory<A, C> interpretationFactory;
         protected PartialModelInitializer initializer;
+        protected List<Rule> decisionRules = new ArrayList<>();
+        protected boolean acceptWasSet;
+        protected @Nullable Criterion accept;
+        protected boolean excludeWasSet;
+        protected @Nullable Criterion exclude;
+        protected boolean objectiveWasSet;
+        protected @Nullable Objective objective;
 
         PartialSymbolTranslator(PartialSymbol<A, C> partialSymbol) {
                 this.partialSymbol = partialSymbol;
@@ -102,6 +114,38 @@ public abstract sealed class PartialSymbolTranslator<A, C> implements AnyPartial
                 return this;
         }
 
+        public PartialSymbolTranslator<A, C> decision(Rule decisionRule) {
+                decisionRules.add(decisionRule);
+                return this;
+        }
+
+        public PartialSymbolTranslator<A, C> accept(@Nullable Criterion acceptanceCriterion) {
+                if (acceptWasSet) {
+                        throw new IllegalStateException("Accept was already set");
+                }
+                this.accept = acceptanceCriterion;
+                acceptWasSet = true;
+                return this;
+        }
+
+        public PartialSymbolTranslator<A, C> exclude(@Nullable Criterion exclusionCriterion) {
+                if (excludeWasSet) {
+                        throw new IllegalStateException("Exclude was already set");
+                }
+                this.exclude = exclusionCriterion;
+                excludeWasSet = true;
+                return this;
+        }
+
+        public PartialSymbolTranslator<A, C> objective(Objective objective) {
+                if (objectiveWasSet) {
+                        throw new IllegalStateException("Objective was already set");
+                }
+                this.objective = objective;
+                objectiveWasSet = true;
+                return this;
+        }
+
         @Override
         public void configure(ModelStoreBuilder storeBuilder) {
                 checkNotConfigured();
@@ -124,6 +168,18 @@ public abstract sealed class PartialSymbolTranslator<A, C> implements AnyPartial
                 if (initializer != null) {
                         reasoningBuilder.initializer(initializer);
                 }
+                storeBuilder.tryGetAdapter(DesignSpaceExplorationBuilder.class).ifPresent(dseBuilder -> {
+                        dseBuilder.transformations(decisionRules);
+                        if (accept != null) {
+                                dseBuilder.accept(accept);
+                        }
+                        if (exclude != null) {
+                                dseBuilder.exclude(exclude);
+                        }
+                });
+                if (objective != null) {
+                        reasoningBuilder.objective(objective);
+                }
         }
 
         private <T> void registerStorageRefiner(ReasoningBuilder reasoningBuilder, StorageRefiner.Factory<T> factory) {
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java
index dda9f2c8..5c3298ac 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java
@@ -5,6 +5,8 @@
  */
 package tools.refinery.store.reasoning.translator.containment;
 
+import tools.refinery.store.dse.transition.DesignSpaceExplorationBuilder;
+import tools.refinery.store.dse.transition.Rule;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.model.ModelStoreConfiguration;
 import tools.refinery.store.query.dnf.Query;
@@ -22,6 +24,7 @@ import tools.refinery.store.reasoning.refinement.RefinementBasedInitializer;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
 import tools.refinery.store.reasoning.translator.RoundingMode;
+import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
 import tools.refinery.store.reasoning.translator.multiplicity.ConstrainedMultiplicity;
 import tools.refinery.store.reasoning.translator.multiplicity.InvalidMultiplicityErrorTranslator;
 import tools.refinery.store.representation.Symbol;
@@ -37,8 +40,9 @@ import static tools.refinery.store.query.literal.Literals.not;
 import static tools.refinery.store.query.term.int_.IntTerms.constant;
 import static tools.refinery.store.query.term.int_.IntTerms.less;
 import static tools.refinery.store.reasoning.ReasoningAdapter.EXISTS_SYMBOL;
-import static tools.refinery.store.reasoning.literal.PartialLiterals.may;
-import static tools.refinery.store.reasoning.literal.PartialLiterals.must;
+import static tools.refinery.store.reasoning.actions.PartialActionLiterals.add;
+import static tools.refinery.store.reasoning.actions.PartialActionLiterals.focus;
+import static tools.refinery.store.reasoning.literal.PartialLiterals.*;
 
 public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
         public static final PartialRelation CONTAINED_SYMBOL = new PartialRelation("contained", 1);
@@ -104,6 +108,7 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
                         translateContainmentLinkType(storeBuilder, linkType, info);
                         translateInvalidMultiplicity(storeBuilder, linkType, info);
                 }
+                translateFocusNotContained(storeBuilder);
         }
 
         private void translateContainmentLinkType(ModelStoreBuilder storeBuilder, PartialRelation linkType,
@@ -188,7 +193,17 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
                                 )))
                                 .roundingMode(RoundingMode.PREFER_FALSE)
                                 .refiner(ContainmentLinkRefiner.of(linkType, containsStorage, info.sourceType(), info.targetType()))
-                                .initializer(new RefinementBasedInitializer<>(linkType)));
+                                .initializer(new RefinementBasedInitializer<>(linkType))
+                                .decision(Rule.of(linkType.name(), (builder, source, target) -> builder
+                                                .clause(
+                                                                may(linkType.call(source, target)),
+                                                                not(candidateMust(linkType.call(source, target))),
+                                                                not(MultiObjectTranslator.MULTI_VIEW.call(source))
+                                                )
+                                                .action(focusedTarget -> List.of(
+                                                                focus(target, focusedTarget),
+                                                                add(linkType, source, focusedTarget)
+                                                )))));
         }
 
         private void translateInvalidMultiplicity(ModelStoreBuilder storeBuilder, PartialRelation linkType,
@@ -216,4 +231,25 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
                 storeBuilder.with(new InvalidMultiplicityErrorTranslator(CONTAINED_SYMBOL, CONTAINS_SYMBOL, true,
                                 ConstrainedMultiplicity.of(CardinalityIntervals.ONE, INVALID_CONTAINER)));
         }
+
+        private void translateFocusNotContained(ModelStoreBuilder storeBuilder) {
+                var dseBuilderOption = storeBuilder.tryGetAdapter(DesignSpaceExplorationBuilder.class);
+                if (dseBuilderOption.isEmpty()) {
+                        return;
+                }
+                var dseBuilder = dseBuilderOption.get();
+                dseBuilder.transformation(Rule.of("NOT_CONTAINED", (builder, multi) -> builder
+                                .clause(
+                                                MultiObjectTranslator.MULTI_VIEW.call(multi),
+                                                not(may(CONTAINED_SYMBOL.call(multi)))
+                                )
+                                .clause((container) -> List.of(
+                                                MultiObjectTranslator.MULTI_VIEW.call(multi),
+                                                must(CONTAINS_SYMBOL.call(container, multi)),
+                                                not(MultiObjectTranslator.MULTI_VIEW.call(container))
+                                ))
+                                .action(
+                                                focus(multi, Variable.of())
+                                )));
+        }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceTranslator.java
index f978aad4..9028337c 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceTranslator.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.reasoning.translator.crossreference;
 
+import tools.refinery.store.dse.transition.Rule;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.model.ModelStoreConfiguration;
 import tools.refinery.store.query.dnf.Query;
@@ -22,8 +23,9 @@ import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.representation.TruthValue;
 
 import static tools.refinery.store.query.literal.Literals.not;
-import static tools.refinery.store.reasoning.literal.PartialLiterals.may;
-import static tools.refinery.store.reasoning.literal.PartialLiterals.must;
+import static tools.refinery.store.reasoning.actions.PartialActionLiterals.add;
+import static tools.refinery.store.reasoning.literal.PartialLiterals.*;
+import static tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator.MULTI_VIEW;
 
 public class DirectedCrossReferenceTranslator implements ModelStoreConfiguration {
         private final PartialRelation linkType;
@@ -67,7 +69,17 @@ public class DirectedCrossReferenceTranslator implements ModelStoreConfiguration
                                         }
                                 }))
                                 .refiner(DirectedCrossReferenceRefiner.of(symbol, sourceType, targetType))
-                                .initializer(new RefinementBasedInitializer<>(linkType)));
+                                .initializer(new RefinementBasedInitializer<>(linkType))
+                                .decision(Rule.of(linkType.name(), (builder, source, target) -> builder
+                                                .clause(
+                                                                may(linkType.call(source, target)),
+                                                                not(candidateMust(linkType.call(source, target))),
+                                                                not(MULTI_VIEW.call(source)),
+                                                                not(MULTI_VIEW.call(target))
+                                                )
+                                                .action(
+                                                                add(linkType, source, target)
+                                                ))));
 
                 storeBuilder.with(new InvalidMultiplicityErrorTranslator(sourceType, linkType, false,
                                 info.sourceMultiplicity()));
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceTranslator.java
index e599992d..c554e2a4 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceTranslator.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.reasoning.translator.crossreference;
 
+import tools.refinery.store.dse.transition.Rule;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.model.ModelStoreConfiguration;
 import tools.refinery.store.query.dnf.Query;
@@ -20,8 +21,9 @@ import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.representation.TruthValue;
 
 import static tools.refinery.store.query.literal.Literals.not;
-import static tools.refinery.store.reasoning.literal.PartialLiterals.may;
-import static tools.refinery.store.reasoning.literal.PartialLiterals.must;
+import static tools.refinery.store.reasoning.actions.PartialActionLiterals.add;
+import static tools.refinery.store.reasoning.literal.PartialLiterals.*;
+import static tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator.MULTI_VIEW;
 
 public class UndirectedCrossReferenceTranslator implements ModelStoreConfiguration {
         private final PartialRelation linkType;
@@ -64,7 +66,17 @@ public class UndirectedCrossReferenceTranslator implements ModelStoreConfigurati
                                         }
                                 }))
                                 .refiner(UndirectedCrossReferenceRefiner.of(symbol, type))
-                                .initializer(new RefinementBasedInitializer<>(linkType)));
+                                .initializer(new RefinementBasedInitializer<>(linkType))
+                                .decision(Rule.of(linkType.name(), (builder, source, target) -> builder
+                                                .clause(
+                                                                may(linkType.call(source, target)),
+                                                                not(candidateMust(linkType.call(source, target))),
+                                                                not(MULTI_VIEW.call(source)),
+                                                                not(MULTI_VIEW.call(target))
+                                                )
+                                                .action(
+                                                                add(linkType, source, target)
+                                                ))));
 
                 storeBuilder.with(new InvalidMultiplicityErrorTranslator(type, linkType, false, info.multiplicity()));
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectTranslator.java
index 735896fa..05704096 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectTranslator.java
@@ -5,9 +5,14 @@
  */
 package tools.refinery.store.reasoning.translator.multiobject;
 
+import tools.refinery.store.dse.transition.objectives.Criteria;
+import tools.refinery.store.dse.transition.objectives.Objectives;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.model.ModelStoreConfiguration;
 import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.term.int_.IntTerms;
+import tools.refinery.store.query.term.uppercardinality.UpperCardinalityTerms;
 import tools.refinery.store.query.view.AnySymbolView;
 import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.ReasoningBuilder;
@@ -23,16 +28,14 @@ import tools.refinery.store.representation.cardinality.UpperCardinality;
 import java.util.List;
 
 import static tools.refinery.store.query.literal.Literals.check;
-import static tools.refinery.store.query.term.int_.IntTerms.constant;
-import static tools.refinery.store.query.term.int_.IntTerms.greaterEq;
-import static tools.refinery.store.query.term.uppercardinality.UpperCardinalityTerms.constant;
-import static tools.refinery.store.query.term.uppercardinality.UpperCardinalityTerms.greaterEq;
+import static tools.refinery.store.query.term.int_.IntTerms.*;
 
 public class MultiObjectTranslator implements ModelStoreConfiguration {
         public static final Symbol<CardinalityInterval> COUNT_STORAGE = Symbol.of("COUNT", 1, CardinalityInterval.class,
                         null);
         public static final AnySymbolView LOWER_CARDINALITY_VIEW = new LowerCardinalityView(COUNT_STORAGE);
         public static final AnySymbolView UPPER_CARDINALITY_VIEW = new UpperCardinalityView(COUNT_STORAGE);
+        public static final AnySymbolView MULTI_VIEW = new MultiView(COUNT_STORAGE);
         public static final PartialFunction<CardinalityInterval, Integer> COUNT_SYMBOL = new PartialFunction<>("COUNT", 1,
                         CardinalityDomain.INSTANCE);
 
@@ -40,11 +43,23 @@ public class MultiObjectTranslator implements ModelStoreConfiguration {
         public void apply(ModelStoreBuilder storeBuilder) {
                 storeBuilder.symbol(COUNT_STORAGE);
 
+                var aboveLowerBound = Query.of("count#aboveLowerBound", Integer.class, (builder, node, output) -> builder
+                                .clause(Integer.class, lowerBound -> List.of(
+                                                LOWER_CARDINALITY_VIEW.call(node, lowerBound),
+                                                output.assign(sub(lowerBound, IntTerms.constant(1))),
+                                                check(greater(output, IntTerms.constant(0)))
+                                )));
+                var missingCardinality = Query.of("count#missing", Integer.class, (builder, output) -> builder
+                                .clause(
+                                                output.assign(aboveLowerBound.aggregate(INT_SUM, Variable.of()))
+                                ));
+
                 storeBuilder.with(PartialRelationTranslator.of(ReasoningAdapter.EXISTS_SYMBOL)
                                 .may(Query.of("exists#may", (builder, p1) -> builder
                                                 .clause(UpperCardinality.class, upper -> List.of(
                                                                 UPPER_CARDINALITY_VIEW.call(p1, upper),
-                                                                check(greaterEq(upper, constant(UpperCardinalities.ONE)))
+                                                                check(UpperCardinalityTerms.greaterEq(upper,
+                                                                                UpperCardinalityTerms.constant(UpperCardinalities.ONE)))
                                                 ))))
                                 .must(Query.of("exists#must", (builder, p1) -> builder
                                                 .clause(Integer.class, lower -> List.of(
@@ -52,11 +67,17 @@ public class MultiObjectTranslator implements ModelStoreConfiguration {
                                                                 check(greaterEq(lower, constant(1)))
                                                 ))))
                                 .roundingMode(RoundingMode.PREFER_FALSE)
-                                .refiner(ExistsRefiner.of(COUNT_STORAGE)));
+                                .refiner(ExistsRefiner.of(COUNT_STORAGE))
+                                .exclude(null)
+                                .accept(Criteria.whenNoMatch(aboveLowerBound))
+                                .objective(Objectives.value(missingCardinality)));
 
                 storeBuilder.with(PartialRelationTranslator.of(ReasoningAdapter.EQUALS_SYMBOL)
                                 .rewriter(EqualsRelationRewriter.of(UPPER_CARDINALITY_VIEW))
-                                .refiner(EqualsRefiner.of(COUNT_STORAGE)));
+                                .refiner(EqualsRefiner.of(COUNT_STORAGE))
+                                .exclude(null)
+                                .accept(null)
+                                .objective(null));
 
                 var reasoningBuilder = storeBuilder.getAdapter(ReasoningBuilder.class);
                 reasoningBuilder.initializer(new MultiObjectInitializer(COUNT_STORAGE));
diff --git a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/MultiView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiView.java
index cea4e07d..498bcd83 100644
--- a/subprojects/store-reasoning-scope/src/main/java/tools/refinery/store/reasoning/scope/internal/MultiView.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiView.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.store.reasoning.scope.internal;
+package tools.refinery.store.reasoning.translator.multiobject;
 
 import tools.refinery.store.query.view.TuplePreservingView;
 import tools.refinery.store.representation.Symbol;
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/InvalidMultiplicityErrorTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/InvalidMultiplicityErrorTranslator.java
index c5e5e83e..ee982f4f 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/InvalidMultiplicityErrorTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/InvalidMultiplicityErrorTranslator.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.reasoning.translator.multiplicity;
 
+import tools.refinery.store.dse.transition.objectives.Objectives;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.model.ModelStoreConfiguration;
 import tools.refinery.store.query.dnf.Query;
@@ -22,7 +23,10 @@ import tools.refinery.store.representation.cardinality.UpperCardinality;
 import java.util.List;
 
 import static tools.refinery.store.query.literal.Literals.check;
+import static tools.refinery.store.query.term.int_.IntTerms.INT_SUM;
+import static tools.refinery.store.query.term.int_.IntTerms.constant;
 import static tools.refinery.store.query.term.int_.IntTerms.greater;
+import static tools.refinery.store.query.term.int_.IntTerms.sub;
 import static tools.refinery.store.query.term.uppercardinality.UpperCardinalityTerms.constant;
 import static tools.refinery.store.query.term.uppercardinality.UpperCardinalityTerms.less;
 import static tools.refinery.store.reasoning.literal.PartialLiterals.candidateMust;
@@ -67,6 +71,8 @@ public class InvalidMultiplicityErrorTranslator implements ModelStoreConfigurati
                                 .parameter(node);
                 var candidateMustBuilder = Query.builder(DnfLifter.decorateName(name, Modality.MUST, Concreteness.PARTIAL))
                                 .parameter(node);
+                var missingOutput = Variable.of("missing", Integer.class);
+                var missingBuilder = Query.builder(name + "#missingMultiplicity").parameter(node).output(missingOutput);
 
                 int lowerBound = cardinalityInterval.lowerBound();
                 if (lowerBound > 0) {
@@ -79,12 +85,18 @@ public class InvalidMultiplicityErrorTranslator implements ModelStoreConfigurati
                         candidateMayBuilder.clause(Integer.class, existingContents -> List.of(
                                         candidateMust(nodeType.call(node)),
                                         new CountCandidateLowerBoundLiteral(existingContents, linkType, arguments),
-                                        check(IntTerms.less(existingContents, IntTerms.constant(lowerBound)))
+                                        check(IntTerms.less(existingContents, constant(lowerBound)))
                         ));
                         candidateMustBuilder.clause(Integer.class, existingContents -> List.of(
                                         candidateMust(nodeType.call(node)),
                                         new CountCandidateUpperBoundLiteral(existingContents, linkType, arguments),
-                                        check(IntTerms.less(existingContents, IntTerms.constant(lowerBound)))
+                                        check(IntTerms.less(existingContents, constant(lowerBound)))
+                        ));
+                        missingBuilder.clause(Integer.class, existingContents -> List.of(
+                                        candidateMust(nodeType.call(node)),
+                                        new CountCandidateLowerBoundLiteral(existingContents, linkType, arguments),
+                                        missingOutput.assign(sub(constant(lowerBound), existingContents)),
+                                        check(greater(missingOutput, constant(0)))
                         ));
                 }
 
@@ -93,24 +105,35 @@ public class InvalidMultiplicityErrorTranslator implements ModelStoreConfigurati
                         mustBuilder.clause(Integer.class, existingContents -> List.of(
                                         must(nodeType.call(node)),
                                         new CountLowerBoundLiteral(existingContents, linkType, arguments),
-                                        check(greater(existingContents, IntTerms.constant(upperBound)))
+                                        check(greater(existingContents, constant(upperBound)))
                         ));
                         candidateMayBuilder.clause(Integer.class, existingContents -> List.of(
                                         candidateMust(nodeType.call(node)),
                                         new CountCandidateUpperBoundLiteral(existingContents, linkType, arguments),
-                                        check(greater(existingContents, IntTerms.constant(upperBound)))
+                                        check(greater(existingContents, constant(upperBound)))
                         ));
                         candidateMustBuilder.clause(Integer.class, existingContents -> List.of(
                                         candidateMust(nodeType.call(node)),
                                         new CountCandidateLowerBoundLiteral(existingContents, linkType, arguments),
-                                        check(greater(existingContents, IntTerms.constant(upperBound)))
+                                        check(greater(existingContents, constant(upperBound)))
+                        ));
+                        missingBuilder.clause(Integer.class, existingContents -> List.of(
+                                        candidateMust(nodeType.call(node)),
+                                        new CountCandidateUpperBoundLiteral(existingContents, linkType, arguments),
+                                        missingOutput.assign(sub(existingContents, constant(upperBound))),
+                                        check(greater(missingOutput, constant(0)))
                         ));
                 }
 
+                var objective = Query.of(name + "#objective", Integer.class, (builder, output) -> builder.clause(
+                                output.assign(missingBuilder.build().aggregate(INT_SUM, Variable.of()))
+                ));
+
                 storeBuilder.with(PartialRelationTranslator.of(constrainedMultiplicity.errorSymbol())
                                 .mayNever()
                                 .must(mustBuilder.build())
                                 .candidateMay(candidateMayBuilder.build())
-                                .candidateMust(candidateMustBuilder.build()));
+                                .candidateMust(candidateMustBuilder.build())
+                                .objective(Objectives.value(objective)));
         }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/predicate/PredicateTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/predicate/PredicateTranslator.java
index 16745da1..b401118e 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/predicate/PredicateTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/predicate/PredicateTranslator.java
@@ -78,7 +78,14 @@ public class PredicateTranslator implements ModelStoreConfiguration {
                                         .clause(mayLiterals)
                                         .build();
                         translator.may(may);
-                } else if (!defaultValue.may()) {
+                } else if (defaultValue.may()) {
+                        // If all values are permitted, we don't need to check for any forbidden values in the model.
+                        // If the result of this predicate of {@code ERROR}, some other partial relation (that we check for)
+                        // will be {@code ERROR} as well.
+                        translator.exclude(null);
+                        translator.accept(null);
+                        translator.objective(null);
+                } else {
                         translator.mayNever();
                 }
                 storeBuilder.with(translator);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslator.java
index 67e8035f..dc8a1d36 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslator.java
@@ -5,16 +5,26 @@
  */
 package tools.refinery.store.reasoning.translator.typehierarchy;
 
+import tools.refinery.store.dse.transition.Rule;
+import tools.refinery.store.dse.transition.actions.ActionLiteral;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.model.ModelStoreConfiguration;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.reasoning.ReasoningBuilder;
+import tools.refinery.store.reasoning.actions.PartialActionLiterals;
 import tools.refinery.store.reasoning.literal.PartialLiterals;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
 import tools.refinery.store.reasoning.translator.proxy.PartialRelationTranslatorProxy;
 import tools.refinery.store.representation.Symbol;
 
+import java.util.ArrayList;
+
+import static tools.refinery.store.query.literal.Literals.not;
+import static tools.refinery.store.reasoning.literal.PartialLiterals.candidateMust;
+import static tools.refinery.store.reasoning.literal.PartialLiterals.may;
+
 public class TypeHierarchyTranslator implements ModelStoreConfiguration {
         private final Symbol<InferredType> typeSymbol = Symbol.of("TYPE", 1, InferredType.class, InferredType.UNTYPED);
         private final TypeHierarchy typeHierarchy;
@@ -49,7 +59,7 @@ public class TypeHierarchyTranslator implements ModelStoreConfiguration {
                                 builder.clause(new MayTypeView(typeSymbol, type).call(p1));
                         }
                         for (var subtype : result.getDirectSubtypes()) {
-                                builder.clause(PartialLiterals.may(subtype.call(p1)));
+                                builder.clause(may(subtype.call(p1)));
                         }
                 });
 
@@ -66,11 +76,31 @@ public class TypeHierarchyTranslator implements ModelStoreConfiguration {
                         }
                 });
 
-                return PartialRelationTranslator.of(type)
+                var translator = PartialRelationTranslator.of(type)
                                 .may(may)
                                 .must(must)
                                 .candidate(candidate)
                                 .refiner(InferredTypeRefiner.of(typeSymbol, result));
+
+                if (!result.isAbstractType()) {
+                        var decision = Rule.of(type.name(), (builder, instance) -> builder
+                                        .clause(
+                                                        may(type.call(instance)),
+                                                        not(candidateMust(type.call(instance))),
+                                                        not(MultiObjectTranslator.MULTI_VIEW.call(instance))
+                                        )
+                                        .action(() -> {
+                                                var actionLiterals = new ArrayList<ActionLiteral>();
+                                                actionLiterals.add(PartialActionLiterals.add(type, instance));
+                                                for (var subtype : result.getDirectSubtypes()) {
+                                                        actionLiterals.add(PartialActionLiterals.remove(subtype, instance));
+                                                }
+                                                return actionLiterals;
+                                        }));
+                        translator.decision(decision);
+                }
+
+                return translator;
         }
 
         private ModelStoreConfiguration createEliminatedTypeTranslator(