feat: declarative DSE rules and model refinement

17 files changed, 543 insertions, 31 deletions

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/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiView.java
new file mode 100644
index 00000000..498bcd83
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiView.java
@@ -0,0 +1,23 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.multiobject;
+
+import tools.refinery.store.query.view.TuplePreservingView;
+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;
+
+class MultiView extends TuplePreservingView<CardinalityInterval> {
+        protected MultiView(Symbol<CardinalityInterval> symbol) {
+                super(symbol, "multi");
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, CardinalityInterval value) {
+                return !CardinalityIntervals.ONE.equals(value);
+        }
+}
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(