Merge pull request #39 from kris7t/partial-interpretation

Implement partial interpretation based model generation

115 files changed, 6037 insertions, 1012 deletions

diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/MergeResult.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/MergeResult.java
deleted file mode 100644
index d3a216d8..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/MergeResult.java
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning;
-
-public enum MergeResult {
-        UNCHANGED,
-        REFINED,
-        REJECTED;
-
-        public MergeResult andAlso(MergeResult other) {
-                return switch (this) {
-                        case UNCHANGED -> other;
-                        case REFINED -> other == REJECTED ? REJECTED : REFINED;
-                        case REJECTED -> REJECTED;
-                };
-        }
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/PartialInterpretation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/PartialInterpretation.java
deleted file mode 100644
index 4140d640..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/PartialInterpretation.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning;
-
-import tools.refinery.store.reasoning.representation.PartialSymbol;
-import tools.refinery.store.map.Cursor;
-import tools.refinery.store.tuple.Tuple;
-
-public non-sealed interface PartialInterpretation<A, C> extends AnyPartialInterpretation {
-        @Override
-        PartialSymbol<A, C> getPartialSymbol();
-
-        A get(Tuple key);
-
-        Cursor<Tuple, A> getAll();
-
-        MergeResult merge(Tuple key, A value);
-
-        C getConcrete(Tuple key);
-
-        Cursor<Tuple, C> getAllConcrete();
-}
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 6d5d6f89..7f0ef8b4 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
@@ -5,26 +5,51 @@
  */
 package tools.refinery.store.reasoning;
 
+import org.jetbrains.annotations.Nullable;
 import tools.refinery.store.adapter.ModelAdapter;
-import tools.refinery.store.query.resultset.ResultSet;
-import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.reasoning.internal.ReasoningBuilderImpl;
+import tools.refinery.store.reasoning.interpretation.AnyPartialInterpretation;
+import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.refinement.AnyPartialInterpretationRefiner;
+import tools.refinery.store.reasoning.refinement.PartialInterpretationRefiner;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.tuple.Tuple1;
 
 public interface ReasoningAdapter extends ModelAdapter {
-        PartialRelation EXISTS = new PartialRelation("exists", 1);
+        PartialRelation EXISTS_SYMBOL = PartialSymbol.of("exists", 1);
+        PartialRelation EQUALS_SYMBOL = PartialSymbol.of("equals", 2);
 
         @Override
         ReasoningStoreAdapter getStoreAdapter();
 
-        default AnyPartialInterpretation getPartialInterpretation(AnyPartialSymbol partialSymbol) {
-                // Cast to disambiguate overloads.
-                var typedPartialSymbol = (PartialSymbol<?, ?>) partialSymbol;
-                return getPartialInterpretation(typedPartialSymbol);
+        default AnyPartialInterpretation getPartialInterpretation(Concreteness concreteness,
+                                                                                                                          AnyPartialSymbol partialSymbol) {
+                return getPartialInterpretation(concreteness, (PartialSymbol<?, ?>) partialSymbol);
         }
 
-        <A, C> PartialInterpretation<A, C> getPartialInterpretation(PartialSymbol<A, C> partialSymbol);
+        <A, C> PartialInterpretation<A, C> getPartialInterpretation(Concreteness concreteness,
+                                                                                                                                PartialSymbol<A, C> partialSymbol);
 
-        ResultSet<Boolean> getLiftedResultSet(Dnf query);
+        default AnyPartialInterpretationRefiner getRefiner(AnyPartialSymbol partialSymbol) {
+                return getRefiner((PartialSymbol<?, ?>) partialSymbol);
+        }
+
+        <A, C> PartialInterpretationRefiner<A, C> getRefiner(PartialSymbol<A, C> partialSymbol);
+
+        @Nullable
+        Tuple1 split(int parentMultiObject);
+
+        @Nullable
+        Tuple1 focus(int parentObject);
+
+        boolean cleanup(int nodeToDelete);
+
+        int getNodeCount();
+
+        static ReasoningBuilder builder() {
+                return new ReasoningBuilderImpl();
+        }
 }
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 d3a337e8..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,27 +6,54 @@
 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.reasoning.literal.Modality;
 import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.FunctionalQuery;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.literal.Modality;
+import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
+import tools.refinery.store.reasoning.refinement.StorageRefiner;
+import tools.refinery.store.reasoning.translator.AnyPartialSymbolTranslator;
+import tools.refinery.store.representation.Symbol;
 
 import java.util.Collection;
 import java.util.List;
 
 @SuppressWarnings("UnusedReturnValue")
 public interface ReasoningBuilder extends ModelAdapterBuilder {
-        default ReasoningBuilder liftedQueries(Dnf... liftedQueries) {
-                return liftedQueries(List.of(liftedQueries));
+        ReasoningBuilder requiredInterpretations(Collection<Concreteness> requiredInterpretations);
+
+        default ReasoningBuilder requiredInterpretations(Concreteness... requiredInterpretations) {
+                return requiredInterpretations(List.of(requiredInterpretations));
         }
 
-        default ReasoningBuilder liftedQueries(Collection<Dnf> liftedQueries) {
-                liftedQueries.forEach(this::liftedQuery);
+        ReasoningBuilder partialSymbol(AnyPartialSymbolTranslator translator);
+
+        <T> ReasoningBuilder storageRefiner(Symbol<T> symbol, StorageRefiner.Factory<T> refiner);
+
+        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;
         }
 
-        ReasoningBuilder liftedQuery(Dnf liftedQuery);
+        <T> Query<T> lift(Modality modality, Concreteness concreteness, Query<T> query);
+
+        RelationalQuery lift(Modality modality, Concreteness concreteness, RelationalQuery query);
+
+        <T> FunctionalQuery<T> lift(Modality modality, Concreteness concreteness, FunctionalQuery<T> query);
 
-        Dnf lift(Modality modality, Dnf query);
+        Dnf lift(Modality modality, Concreteness concreteness, Dnf dnf);
 
         @Override
         ReasoningStoreAdapter build(ModelStore store);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java
index c9795255..fe3cc3ea 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java
@@ -7,15 +7,21 @@ package tools.refinery.store.reasoning;
 
 import tools.refinery.store.adapter.ModelStoreAdapter;
 import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
-import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.reasoning.seed.ModelSeed;
 
 import java.util.Collection;
+import java.util.Set;
 
 public interface ReasoningStoreAdapter extends ModelStoreAdapter {
         Collection<AnyPartialSymbol> getPartialSymbols();
 
-        Collection<Dnf> getLiftedQueries();
+        Collection<AnyPartialSymbol> getRefinablePartialSymbols();
+
+        Set<Concreteness> getSupportedInterpretations();
+
+        Model createInitialModel(ModelSeed modelSeed);
 
         @Override
         ReasoningAdapter createModelAdapter(Model model);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/actions/CleanupActionLiteral.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/actions/CleanupActionLiteral.java
new file mode 100644
index 00000000..62c35cee
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/actions/CleanupActionLiteral.java
@@ -0,0 +1,43 @@
+/*
+ * 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.tuple.Tuple;
+
+import java.util.List;
+
+public class CleanupActionLiteral extends AbstractActionLiteral {
+        private final NodeVariable node;
+
+        public CleanupActionLiteral(NodeVariable node) {
+                this.node = node;
+        }
+
+        public NodeVariable getNode() {
+                return node;
+        }
+
+        @Override
+        public List<NodeVariable> getInputVariables() {
+                return List.of(node);
+        }
+
+        @Override
+        public List<NodeVariable> getOutputVariables() {
+                return List.of();
+        }
+
+        @Override
+        public BoundActionLiteral bindToModel(Model model) {
+                var reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
+                return tuple -> reasoningAdapter.cleanup(tuple.get(0)) ? Tuple.of() : null;
+        }
+}
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..f36fde44
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/actions/PartialActionLiterals.java
@@ -0,0 +1,42 @@
+/*
+ * 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);
+        }
+
+        public static CleanupActionLiteral cleanup(NodeVariable node) {
+                return new CleanupActionLiteral(node);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/PartialClauseRewriter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/PartialClauseRewriter.java
new file mode 100644
index 00000000..40993235
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/PartialClauseRewriter.java
@@ -0,0 +1,223 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.internal;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.DnfBuilder;
+import tools.refinery.store.query.dnf.DnfClause;
+import tools.refinery.store.query.literal.AbstractCallLiteral;
+import tools.refinery.store.query.literal.AbstractCountLiteral;
+import tools.refinery.store.query.literal.CallPolarity;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.Aggregator;
+import tools.refinery.store.query.term.ConstantTerm;
+import tools.refinery.store.query.term.Term;
+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.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.literal.*;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
+import tools.refinery.store.representation.cardinality.UpperCardinalities;
+
+import java.util.*;
+import java.util.function.BinaryOperator;
+
+class PartialClauseRewriter {
+        private final PartialQueryRewriter rewriter;
+        private final List<Literal> completedLiterals = new ArrayList<>();
+        private final Deque<Literal> workList = new ArrayDeque<>();
+        private final Set<Variable> positiveVariables = new LinkedHashSet<>();
+        private final Set<Variable> unmodifiablePositiveVariables = Collections.unmodifiableSet(positiveVariables);
+
+        public PartialClauseRewriter(PartialQueryRewriter rewriter) {
+                this.rewriter = rewriter;
+        }
+
+        public List<Literal> rewriteClause(DnfClause clause) {
+                workList.addAll(clause.literals());
+                while (!workList.isEmpty()) {
+                        var literal = workList.removeFirst();
+                        rewrite(literal);
+                }
+                return completedLiterals;
+        }
+
+        private void rewrite(Literal literal) {
+                if (!(literal instanceof AbstractCallLiteral callLiteral)) {
+                        markAsDone(literal);
+                        return;
+                }
+                if (callLiteral instanceof CountLowerBoundLiteral countLowerBoundLiteral) {
+                        rewriteCountLowerBound(countLowerBoundLiteral);
+                        return;
+                }
+                if (callLiteral instanceof CountUpperBoundLiteral countUpperBoundLiteral) {
+                        rewriteCountUpperBound(countUpperBoundLiteral);
+                        return;
+                }
+                if (callLiteral instanceof CountCandidateLowerBoundLiteral countCandidateLowerBoundLiteral) {
+                        rewriteCountCandidateLowerBound(countCandidateLowerBoundLiteral);
+                        return;
+                }
+                if (callLiteral instanceof CountCandidateUpperBoundLiteral countCandidateUpperBoundLiteral) {
+                        rewriteCountCandidateUpperBound(countCandidateUpperBoundLiteral);
+                        return;
+                }
+                var target = callLiteral.getTarget();
+                if (target instanceof Dnf dnf) {
+                        rewriteRecursively(callLiteral, dnf);
+                } else if (target instanceof ModalConstraint modalConstraint) {
+                        var modality = modalConstraint.modality();
+                        var concreteness = modalConstraint.concreteness();
+                        var constraint = modalConstraint.constraint();
+                        if (constraint instanceof Dnf dnf) {
+                                rewriteRecursively(callLiteral, modality, concreteness, dnf);
+                        } else if (constraint instanceof PartialRelation partialRelation) {
+                                rewrite(callLiteral, modality, concreteness, partialRelation);
+                        } else {
+                                throw new IllegalArgumentException("Cannot interpret modal constraint: " + modalConstraint);
+                        }
+                } else {
+                        markAsDone(literal);
+                }
+        }
+
+        private void rewriteCountLowerBound(CountLowerBoundLiteral literal) {
+                rewritePartialCount(literal, "lower", Modality.MUST, MultiObjectTranslator.LOWER_CARDINALITY_VIEW, 1,
+                                IntTerms::mul, IntTerms.INT_SUM);
+        }
+
+        private void rewriteCountUpperBound(CountUpperBoundLiteral literal) {
+                rewritePartialCount(literal, "upper", Modality.MAY, MultiObjectTranslator.UPPER_CARDINALITY_VIEW,
+                                UpperCardinalities.ONE, UpperCardinalityTerms::mul, UpperCardinalityTerms.UPPER_CARDINALITY_SUM);
+        }
+
+        private <T> void rewritePartialCount(AbstractCountLiteral<T> literal, String name, Modality modality,
+                                                                                 Constraint view, T one, BinaryOperator<Term<T>> mul, Aggregator<T, T> sum) {
+                var type = literal.getResultType();
+                var countResult = computeCountVariables(literal, Concreteness.PARTIAL, name);
+                var builder = countResult.builder();
+                var outputVariable = builder.parameter(type);
+                var variablesToCount = countResult.variablesToCount();
+
+                var literals = new ArrayList<Literal>();
+                literals.add(new ModalConstraint(modality, Concreteness.PARTIAL, literal.getTarget())
+                                .call(CallPolarity.POSITIVE, countResult.rewrittenArguments()));
+                switch (variablesToCount.size()) {
+                case 0 -> literals.add(outputVariable.assign(new ConstantTerm<>(type, one)));
+                case 1 -> literals.add(view.call(variablesToCount.get(0),
+                                outputVariable));
+                default -> {
+                        var firstCount = Variable.of(type);
+                        literals.add(view.call(variablesToCount.get(0), firstCount));
+                        int length = variablesToCount.size();
+                        Term<T> accumulator = firstCount;
+                        for (int i = 1; i < length; i++) {
+                                var countVariable = Variable.of(type);
+                                literals.add(view.call(variablesToCount.get(i), countVariable));
+                                accumulator = mul.apply(accumulator, countVariable);
+                        }
+                        literals.add(outputVariable.assign(accumulator));
+                }
+                }
+                builder.clause(literals);
+
+                var helperQuery = builder.build();
+                var aggregationVariable = Variable.of(type);
+                var helperArguments = countResult.helperArguments();
+                helperArguments.add(aggregationVariable);
+                workList.addFirst(literal.getResultVariable().assign(helperQuery.aggregateBy(aggregationVariable, sum,
+                                helperArguments)));
+        }
+
+        private void rewriteCountCandidateLowerBound(CountCandidateLowerBoundLiteral literal) {
+                rewriteCandidateCount(literal, "lower", Modality.MAY);
+        }
+
+        private void rewriteCountCandidateUpperBound(CountCandidateUpperBoundLiteral literal) {
+                rewriteCandidateCount(literal, "upper", Modality.MUST);
+        }
+
+        private void rewriteCandidateCount(AbstractCountLiteral<Integer> literal, String name, Modality modality) {
+                var countResult = computeCountVariables(literal, Concreteness.CANDIDATE, name);
+                var builder = countResult.builder();
+
+                var literals = new ArrayList<Literal>();
+                literals.add(new ModalConstraint(modality, Concreteness.CANDIDATE, literal.getTarget())
+                                .call(CallPolarity.POSITIVE, countResult.rewrittenArguments()));
+                for (var variable : countResult.variablesToCount()) {
+                        literals.add(new ModalConstraint(modality, Concreteness.CANDIDATE, ReasoningAdapter.EXISTS_SYMBOL)
+                                        .call(variable));
+                }
+                builder.clause(literals);
+
+                var helperQuery = builder.build();
+                workList.addFirst(literal.getResultVariable().assign(helperQuery.count(countResult.helperArguments())));
+        }
+
+        private CountResult computeCountVariables(AbstractCountLiteral<?> literal, Concreteness concreteness,
+                                                                                          String name) {
+                var target = literal.getTarget();
+                int arity = target.arity();
+                var parameters = target.getParameters();
+                var literalArguments = literal.getArguments();
+                var privateVariables = literal.getPrivateVariables(positiveVariables);
+                var builder = Dnf.builder("%s#%s#%s".formatted(target.name(), concreteness, name));
+                var rewrittenArguments = new ArrayList<Variable>(parameters.size());
+                var variablesToCount = new ArrayList<Variable>();
+                var helperArguments = new ArrayList<Variable>();
+                var literalToRewrittenArgumentMap = new HashMap<Variable, Variable>();
+                for (int i = 0; i < arity; i++) {
+                        var literalArgument = literalArguments.get(i);
+                        var parameter = parameters.get(i);
+                        var rewrittenArgument = literalToRewrittenArgumentMap.computeIfAbsent(literalArgument, key -> {
+                                helperArguments.add(key);
+                                var newArgument = builder.parameter(parameter);
+                                if (privateVariables.contains(key)) {
+                                        variablesToCount.add(newArgument);
+                                }
+                                return newArgument;
+                        });
+                        rewrittenArguments.add(rewrittenArgument);
+                }
+                return new CountResult(builder, rewrittenArguments, helperArguments, variablesToCount);
+        }
+
+        private void markAsDone(Literal literal) {
+                completedLiterals.add(literal);
+                positiveVariables.addAll(literal.getOutputVariables());
+        }
+
+        private void rewriteRecursively(AbstractCallLiteral callLiteral, Modality modality, Concreteness concreteness,
+                                                                        Dnf dnf) {
+                var liftedDnf = rewriter.getLifter().lift(modality, concreteness, dnf);
+                rewriteRecursively(callLiteral, liftedDnf);
+        }
+
+        private void rewriteRecursively(AbstractCallLiteral callLiteral, Dnf dnf) {
+                var rewrittenDnf = rewriter.rewrite(dnf);
+                var rewrittenLiteral = callLiteral.withTarget(rewrittenDnf);
+                markAsDone(rewrittenLiteral);
+        }
+
+        private void rewrite(AbstractCallLiteral callLiteral, Modality modality, Concreteness concreteness,
+                                                 PartialRelation partialRelation) {
+                var relationRewriter = rewriter.getRelationRewriter(partialRelation);
+                var literals = relationRewriter.rewriteLiteral(
+                                unmodifiablePositiveVariables, callLiteral, modality, concreteness);
+                int length = literals.size();
+                for (int i = length - 1; i >= 0; i--) {
+                        workList.addFirst(literals.get(i));
+                }
+        }
+
+        private record CountResult(DnfBuilder builder, List<Variable> rewrittenArguments, List<Variable> helperArguments,
+                                                           List<Variable> variablesToCount) {
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/PartialQueryRewriter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/PartialQueryRewriter.java
new file mode 100644
index 00000000..79cba263
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/PartialQueryRewriter.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.internal;
+
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.rewriter.AbstractRecursiveRewriter;
+import tools.refinery.store.reasoning.interpretation.PartialRelationRewriter;
+import tools.refinery.store.reasoning.lifting.DnfLifter;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+
+import java.util.HashMap;
+import java.util.Map;
+
+class PartialQueryRewriter extends AbstractRecursiveRewriter {
+        private final DnfLifter lifter;
+        private final Map<PartialRelation, PartialRelationRewriter> relationRewriterMap = new HashMap<>();
+
+        PartialQueryRewriter(DnfLifter lifter) {
+                this.lifter = lifter;
+        }
+
+        DnfLifter getLifter() {
+                return lifter;
+        }
+
+        PartialRelationRewriter getRelationRewriter(PartialRelation partialRelation) {
+                var rewriter = relationRewriterMap.get(partialRelation);
+                if (rewriter == null) {
+                        throw new IllegalArgumentException("Do not know how to interpret partial relation: " + partialRelation);
+                }
+                return rewriter;
+        }
+
+        public void addRelationRewriter(PartialRelation partialRelation, PartialRelationRewriter interpreter) {
+                if (relationRewriterMap.put(partialRelation, interpreter) != null) {
+                        throw new IllegalArgumentException("Duplicate partial relation: " + partialRelation);
+                }
+        }
+
+        @Override
+        protected Dnf doRewrite(Dnf dnf) {
+                var builder = Dnf.builderFrom(dnf);
+                for (var clause : dnf.getClauses()) {
+                        var clauseRewriter = new PartialClauseRewriter(this);
+                        var rewrittenClauses = clauseRewriter.rewriteClause(clause);
+                        builder.clause(rewrittenClauses);
+                }
+                return builder.build();
+        }
+}
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 1bd3ad2e..bd16bdfa 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
@@ -5,20 +5,114 @@
  */
 package tools.refinery.store.reasoning.internal;
 
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.reasoning.ReasoningAdapter;
-import tools.refinery.store.reasoning.PartialInterpretation;
+import tools.refinery.store.reasoning.interpretation.AnyPartialInterpretation;
+import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.refinement.AnyPartialInterpretationRefiner;
+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.query.dnf.Dnf;
-import tools.refinery.store.query.resultset.ResultSet;
+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;
 
-public class ReasoningAdapterImpl implements ReasoningAdapter {
+import java.util.HashMap;
+import java.util.Map;
+
+class ReasoningAdapterImpl implements ReasoningAdapter {
+        static final Symbol<Integer> NODE_COUNT_SYMBOL = Symbol.of("MODEL_SIZE", 0, Integer.class, 0);
         private final Model model;
         private final ReasoningStoreAdapterImpl storeAdapter;
+        private final Map<AnyPartialSymbol, AnyPartialInterpretation>[] partialInterpretations;
+        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;
                 this.storeAdapter = storeAdapter;
+
+                int concretenessLength = Concreteness.values().length;
+                // Creation of a generic array.
+                @SuppressWarnings({"unchecked", "squid:S1905"})
+                var interpretationsArray = (Map<AnyPartialSymbol, AnyPartialInterpretation>[]) new Map[concretenessLength];
+                partialInterpretations = interpretationsArray;
+                createPartialInterpretations();
+
+                var refinerFactories = storeAdapter.getSymbolRefiners();
+                refiners = new HashMap<>(refinerFactories.size());
+                createRefiners();
+
+                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() {
+                var supportedInterpretations = storeAdapter.getSupportedInterpretations();
+                int concretenessLength = Concreteness.values().length;
+                var interpretationFactories = storeAdapter.getSymbolInterpreters();
+                for (int i = 0; i < concretenessLength; i++) {
+                        var concreteness = Concreteness.values()[i];
+                        if (supportedInterpretations.contains(concreteness)) {
+                                partialInterpretations[i] = new HashMap<>(interpretationFactories.size());
+                        }
+                }
+                // Create the partial interpretations in order so that factories may refer to interpretations of symbols
+                // preceding them in the ordered {@code interpretationFactories} map, e.g., for opposite interpretations.
+                for (var entry : interpretationFactories.entrySet()) {
+                        var partialSymbol = entry.getKey();
+                        var factory = entry.getValue();
+                        for (int i = 0; i < concretenessLength; i++) {
+                                if (partialInterpretations[i] != null) {
+                                        var concreteness = Concreteness.values()[i];
+                                        var interpretation = createPartialInterpretation(concreteness, factory, partialSymbol);
+                                        partialInterpretations[i].put(partialSymbol, interpretation);
+                                }
+                        }
+                }
+        }
+
+        private <A, C> PartialInterpretation<A, C> createPartialInterpretation(
+                        Concreteness concreteness, PartialInterpretation.Factory<A, C> interpreter, AnyPartialSymbol symbol) {
+                // The builder only allows well-typed assignment of interpreters to symbols.
+                @SuppressWarnings("unchecked")
+                var typedSymbol = (PartialSymbol<A, C>) symbol;
+                return interpreter.create(this, concreteness, typedSymbol);
+        }
+
+        private void createRefiners() {
+                var refinerFactories = storeAdapter.getSymbolRefiners();
+                // Create the partial interpretations refiners in order so that factories may refer to refiners of symbols
+                // preceding them in the ordered {@code interpretationFactories} map, e.g., for opposite interpretations.
+                for (var entry : refinerFactories.entrySet()) {
+                        var partialSymbol = entry.getKey();
+                        var factory = entry.getValue();
+                        var refiner = createRefiner(factory, partialSymbol);
+                        refiners.put(partialSymbol, refiner);
+                }
+        }
+
+        private <A, C> PartialInterpretationRefiner<A, C> createRefiner(
+                        PartialInterpretationRefiner.Factory<A, C> factory, AnyPartialSymbol symbol) {
+                // The builder only allows well-typed assignment of interpreters to symbols.
+                @SuppressWarnings("unchecked")
+                var typedSymbol = (PartialSymbol<A, C>) symbol;
+                return factory.create(this, typedSymbol);
         }
 
         @Override
@@ -32,12 +126,88 @@ public class ReasoningAdapterImpl implements ReasoningAdapter {
         }
 
         @Override
-        public <A, C> PartialInterpretation<A, C> getPartialInterpretation(PartialSymbol<A, C> partialSymbol) {
-                return null;
+        public <A, C> PartialInterpretation<A, C> getPartialInterpretation(Concreteness concreteness,
+                                                                                                                                           PartialSymbol<A, C> partialSymbol) {
+                var map = partialInterpretations[concreteness.ordinal()];
+                if (map == null) {
+                        throw new IllegalArgumentException("No interpretation for concreteness: " + concreteness);
+                }
+                var interpretation = map.get(partialSymbol);
+                if (interpretation == null) {
+                        throw new IllegalArgumentException("No interpretation for partial symbol: " + partialSymbol);
+                }
+                // The builder only allows well-typed assignment of interpreters to symbols.
+                @SuppressWarnings("unchecked")
+                var typedInterpretation = (PartialInterpretation<A, C>) interpretation;
+                return typedInterpretation;
+        }
+
+        @Override
+        public <A, C> PartialInterpretationRefiner<A, C> getRefiner(PartialSymbol<A, C> partialSymbol) {
+                var refiner = refiners.get(partialSymbol);
+                if (refiner == null) {
+                        throw new IllegalArgumentException("No refiner for partial symbol: " + partialSymbol);
+                }
+                // The builder only allows well-typed assignment of refiners to symbols.
+                @SuppressWarnings("unchecked")
+                var typedRefiner = (PartialInterpretationRefiner<A, C>) refiner;
+                return typedRefiner;
+        }
+
+        @Override
+        @Nullable
+        public Tuple1 split(int parentNode) {
+                int newNodeId = nodeCountInterpretation.get(Tuple.of());
+                nodeCountInterpretation.put(Tuple.of(), newNodeId + 1);
+                // Avoid creating an iterator object.
+                //noinspection ForLoopReplaceableByForEach
+                for (int i = 0; i < storageRefiners.length; i++) {
+                        if (!storageRefiners[i].split(parentNode, newNodeId)) {
+                                return null;
+                        }
+                }
+                return Tuple.of(newNodeId);
+        }
+
+        @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
+                for (int i = 0; i < storageRefiners.length; i++) {
+                        if (!storageRefiners[i].cleanup(nodeToDelete)) {
+                                return false;
+                        }
+                }
+                int currentModelSize = nodeCountInterpretation.get(Tuple.of());
+                if (nodeToDelete == currentModelSize - 1) {
+                        nodeCountInterpretation.put(Tuple.of(), nodeToDelete);
+                }
+                return true;
         }
 
         @Override
-        public ResultSet<Boolean> getLiftedResultSet(Dnf query) {
-                return null;
+        public int getNodeCount() {
+                Integer nodeCount = nodeCountInterpretation.get(Tuple.of());
+                return nodeCount == null ? 0 : nodeCount;
         }
 }
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 aa71496c..722458c8 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,26 +6,169 @@
 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;
 import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.FunctionalQuery;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.dnf.RelationalQuery;
 import tools.refinery.store.reasoning.ReasoningBuilder;
+import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
+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.refinement.DefaultStorageRefiner;
+import tools.refinery.store.reasoning.refinement.PartialInterpretationRefiner;
+import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
+import tools.refinery.store.reasoning.refinement.StorageRefiner;
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+import tools.refinery.store.reasoning.translator.AnyPartialSymbolTranslator;
+import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.statecoding.StateCoderBuilder;
+
+import java.util.*;
 
 public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder<ReasoningStoreAdapterImpl>
                 implements ReasoningBuilder {
+        private final DnfLifter lifter = new DnfLifter();
+        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, 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) {
+                this.requiredInterpretations = Set.copyOf(requiredInterpretations);
+                return this;
+        }
+
+        @Override
+        public ReasoningBuilder partialSymbol(AnyPartialSymbolTranslator translator) {
+                var partialSymbol = translator.getPartialSymbol();
+                var oldConfiguration = translators.put(partialSymbol, translator);
+                if (oldConfiguration != null && oldConfiguration != translator) {
+                        throw new IllegalArgumentException("Duplicate configuration for symbol: " + partialSymbol);
+                }
+                return this;
+        }
+
         @Override
-        public ReasoningBuilder liftedQuery(Dnf liftedQuery) {
-                return null;
+        public <T> ReasoningBuilder storageRefiner(Symbol<T> symbol, StorageRefiner.Factory<T> refiner) {
+                checkNotConfigured();
+                if (registeredStorageRefiners.put(symbol, refiner) != null) {
+                        throw new IllegalArgumentException("Duplicate representation refiner for symbol: " + symbol);
+                }
+                return this;
+        }
+
+        @Override
+        public ReasoningBuilder initializer(PartialModelInitializer initializer) {
+                checkNotConfigured();
+                initializers.add(initializer);
+                return this;
         }
 
         @Override
-        public Dnf lift(Modality modality, Dnf query) {
+        public ReasoningBuilder objective(Objective objective) {
                 checkNotConfigured();
-                return null;
+                objectives.add(objective);
+                return this;
+        }
+
+        @Override
+        public <T> Query<T> lift(Modality modality, Concreteness concreteness, Query<T> query) {
+                return lifter.lift(modality, concreteness, query);
+        }
+
+        @Override
+        public RelationalQuery lift(Modality modality, Concreteness concreteness, RelationalQuery query) {
+                return lifter.lift(modality, concreteness, query);
+        }
+
+        @Override
+        public <T> FunctionalQuery<T> lift(Modality modality, Concreteness concreteness, FunctionalQuery<T> query) {
+                return lifter.lift(modality, concreteness, query);
+        }
+
+        @Override
+        public Dnf lift(Modality modality, Concreteness concreteness, Dnf dnf) {
+                return lifter.lift(modality, concreteness, dnf);
+        }
+
+        @Override
+        protected void doConfigure(ModelStoreBuilder storeBuilder) {
+                storeBuilder.symbols(ReasoningAdapterImpl.NODE_COUNT_SYMBOL);
+                storeBuilder.tryGetAdapter(StateCoderBuilder.class)
+                                .ifPresent(stateCoderBuilder -> stateCoderBuilder.exclude(ReasoningAdapterImpl.NODE_COUNT_SYMBOL));
+                for (var translator : translators.values()) {
+                        translator.configure(storeBuilder);
+                        if (translator instanceof PartialRelationTranslator relationConfiguration) {
+                                doConfigure(storeBuilder, relationConfiguration);
+                        } else {
+                                throw new IllegalArgumentException("Unknown partial symbol translator %s for partial symbol %s"
+                                                .formatted(translator, translator.getPartialSymbol()));
+                        }
+                }
+                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) {
+                var partialRelation = relationConfiguration.getPartialRelation();
+                queryRewriter.addRelationRewriter(partialRelation, relationConfiguration.getRewriter());
+                var interpretationFactory = relationConfiguration.getInterpretationFactory();
+                interpretationFactory.configure(storeBuilder, requiredInterpretations);
+                symbolInterpreters.put(partialRelation, interpretationFactory);
+                var refiner = relationConfiguration.getInterpretationRefiner();
+                if (refiner != null) {
+                        symbolRefiners.put(partialRelation, refiner);
+                }
         }
 
         @Override
         public ReasoningStoreAdapterImpl doBuild(ModelStore store) {
-                return null;
+                return new ReasoningStoreAdapterImpl(store, requiredInterpretations,
+                                Collections.unmodifiableMap(symbolInterpreters), Collections.unmodifiableMap(symbolRefiners),
+                                getStorageRefiners(store), Collections.unmodifiableList(initializers));
+        }
+
+        private Map<AnySymbol, StorageRefiner.Factory<?>> getStorageRefiners(ModelStore store) {
+                var symbols = store.getSymbols();
+                var storageRefiners = new LinkedHashMap<AnySymbol, StorageRefiner.Factory<?>>(symbols.size());
+                for (var symbol : symbols) {
+                        var refiner = registeredStorageRefiners.remove(symbol);
+                        if (refiner == null) {
+                                if (symbol.arity() == 0) {
+                                        // Arity-0 symbols don't need a default refiner, because they are unaffected by object
+                                        // creation/removal. Only a custom refiner ({@code refiner != null}) might need to update them.
+                                        continue;
+                                }
+                                // By default, copy over all affected tuples on object creation and remove all affected tuples on
+                                // object removal.
+                                refiner = DefaultStorageRefiner.factory();
+                        }
+                        storageRefiners.put(symbol, refiner);
+                }
+                if (!registeredStorageRefiners.isEmpty()) {
+                        throw new IllegalArgumentException("Unused storage refiners: " + registeredStorageRefiners.keySet());
+                }
+                return Collections.unmodifiableMap(storageRefiners);
         }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java
index cdddd8d6..9ef6fb16 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java
@@ -5,19 +5,46 @@
  */
 package tools.refinery.store.reasoning.internal;
 
-import tools.refinery.store.reasoning.ReasoningStoreAdapter;
+import tools.refinery.store.dse.propagation.PropagationAdapter;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.reasoning.ReasoningStoreAdapter;
+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;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
-import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
 
 import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
-public class ReasoningStoreAdapterImpl implements ReasoningStoreAdapter {
+class ReasoningStoreAdapterImpl implements ReasoningStoreAdapter {
         private final ModelStore store;
+        private final Set<Concreteness> supportedInterpretations;
+        private final Map<AnyPartialSymbol, PartialInterpretation.Factory<?, ?>> symbolInterpreters;
+        private final Map<AnyPartialSymbol, PartialInterpretationRefiner.Factory<?, ?>> symbolRefiners;
+        private final Map<AnySymbol, StorageRefiner.Factory<?>> storageRefiners;
+        private final List<PartialModelInitializer> initializers;
 
-        ReasoningStoreAdapterImpl(ModelStore store) {
+        ReasoningStoreAdapterImpl(ModelStore store, Set<Concreteness> supportedInterpretations,
+                                                          Map<AnyPartialSymbol, PartialInterpretation.Factory<?, ?>> symbolInterpreters,
+                                                          Map<AnyPartialSymbol, PartialInterpretationRefiner.Factory<?, ?>> symbolRefiners,
+                                                          Map<AnySymbol, StorageRefiner.Factory<?>> storageRefiners,
+                                                          List<PartialModelInitializer> initializers) {
                 this.store = store;
+                this.supportedInterpretations = supportedInterpretations;
+                this.symbolInterpreters = symbolInterpreters;
+                this.symbolRefiners = symbolRefiners;
+                this.storageRefiners = storageRefiners;
+                this.initializers = initializers;
         }
 
         @Override
@@ -26,13 +53,64 @@ public class ReasoningStoreAdapterImpl implements ReasoningStoreAdapter {
         }
 
         @Override
+        public Set<Concreteness> getSupportedInterpretations() {
+                return supportedInterpretations;
+        }
+
+        @Override
         public Collection<AnyPartialSymbol> getPartialSymbols() {
-                return null;
+                return symbolInterpreters.keySet();
         }
 
         @Override
-        public Collection<Dnf> getLiftedQueries() {
-                return null;
+        public Collection<AnyPartialSymbol> getRefinablePartialSymbols() {
+                return symbolRefiners.keySet();
+        }
+
+        // Use of wildcard return value only in internal method not exposed as API, so there is less chance of confusion.
+        @SuppressWarnings("squid:S1452")
+        Map<AnyPartialSymbol, PartialInterpretation.Factory<?, ?>> getSymbolInterpreters() {
+                return symbolInterpreters;
+        }
+
+        // Use of wildcard return value only in internal method not exposed as API, so there is less chance of confusion.
+        @SuppressWarnings("squid:S1452")
+        Map<AnyPartialSymbol, PartialInterpretationRefiner.Factory<?, ?>> getSymbolRefiners() {
+                return symbolRefiners;
+        }
+
+        StorageRefiner[] createStorageRefiner(Model model) {
+                var refiners = new StorageRefiner[storageRefiners.size()];
+                int i = 0;
+                for (var entry : storageRefiners.entrySet()) {
+                        var symbol = entry.getKey();
+                        var factory = entry.getValue();
+                        refiners[i] = createStorageRefiner(factory, model, symbol);
+                        i++;
+                }
+                return refiners;
+        }
+
+        private <T> StorageRefiner createStorageRefiner(StorageRefiner.Factory<T> factory, Model model, AnySymbol symbol) {
+                // The builder only allows well-typed assignment of refiners to symbols.
+                @SuppressWarnings("unchecked")
+                var typedSymbol = (Symbol<T>) symbol;
+                return factory.create(typedSymbol, model);
+        }
+
+        public Model createInitialModel(ModelSeed modelSeed) {
+                var model = store.createEmptyModel();
+                model.getInterpretation(ReasoningAdapterImpl.NODE_COUNT_SYMBOL).put(Tuple.of(), modelSeed.getNodeCount());
+                for (var initializer : initializers) {
+                        initializer.initialize(model, modelSeed);
+                }
+                model.tryGetAdapter(PropagationAdapter.class).ifPresent(propagationAdapter -> {
+                        if (propagationAdapter.propagate().isRejected()) {
+                                throw new IllegalArgumentException("Inconsistent initial mode: propagation failed");
+                        }
+                });
+                model.getAdapter(ModelQueryAdapter.class).flushChanges();
+                return model;
         }
 
         @Override
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/AbstractPartialInterpretation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/AbstractPartialInterpretation.java
new file mode 100644
index 00000000..ed291eac
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/AbstractPartialInterpretation.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.interpretation;
+
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+
+public abstract class AbstractPartialInterpretation<A, C> implements PartialInterpretation<A, C> {
+        private final ReasoningAdapter adapter;
+        private final PartialSymbol<A, C> partialSymbol;
+        private final Concreteness concreteness;
+
+        protected AbstractPartialInterpretation(ReasoningAdapter adapter, Concreteness concreteness,
+                                                                                        PartialSymbol<A, C> partialSymbol) {
+                this.adapter = adapter;
+                this.partialSymbol = partialSymbol;
+                this.concreteness = concreteness;
+        }
+
+        @Override
+        public ReasoningAdapter getAdapter() {
+                return adapter;
+        }
+
+        @Override
+        public PartialSymbol<A, C> getPartialSymbol() {
+                return partialSymbol;
+        }
+
+        @Override
+        public Concreteness getConcreteness() {
+                return concreteness;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/AnyPartialInterpretation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/AnyPartialInterpretation.java
index 000171a1..cd709bc4 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/AnyPartialInterpretation.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/AnyPartialInterpretation.java
@@ -3,8 +3,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.store.reasoning;
+package tools.refinery.store.reasoning.interpretation;
 
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 
 public sealed interface AnyPartialInterpretation permits PartialInterpretation {
@@ -12,7 +14,5 @@ public sealed interface AnyPartialInterpretation permits PartialInterpretation {
 
         AnyPartialSymbol getPartialSymbol();
 
-        int countUnfinished();
-
-        int countErrors();
+        Concreteness getConcreteness();
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/PartialInterpretation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/PartialInterpretation.java
new file mode 100644
index 00000000..86ffe751
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/PartialInterpretation.java
@@ -0,0 +1,34 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.interpretation;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Set;
+
+public non-sealed interface PartialInterpretation<A, C> extends AnyPartialInterpretation {
+        @Override
+        PartialSymbol<A, C> getPartialSymbol();
+
+        A get(Tuple key);
+
+        Cursor<Tuple, A> getAll();
+
+        @FunctionalInterface
+        interface Factory<A, C> {
+                PartialInterpretation<A, C> create(ReasoningAdapter adapter, Concreteness concreteness,
+                                                                                   PartialSymbol<A, C> partialSymbol);
+
+                default void configure(ModelStoreBuilder storeBuilder, Set<Concreteness> requiredInterpretations) {
+                        // Nothing to configure by default.
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/PartialRelationRewriter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/PartialRelationRewriter.java
new file mode 100644
index 00000000..6ad35c20
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/PartialRelationRewriter.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.interpretation;
+
+import tools.refinery.store.query.literal.AbstractCallLiteral;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.literal.Modality;
+
+import java.util.List;
+import java.util.Set;
+
+@FunctionalInterface
+public interface PartialRelationRewriter {
+        List<Literal> rewriteLiteral(Set<Variable> positiveVariables, AbstractCallLiteral literal, Modality modality,
+                                                                 Concreteness concreteness);
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/QueryBasedRelationInterpretationFactory.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/QueryBasedRelationInterpretationFactory.java
new file mode 100644
index 00000000..5cdaa185
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/QueryBasedRelationInterpretationFactory.java
@@ -0,0 +1,195 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.interpretation;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.ModelQueryBuilder;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.resultset.ResultSet;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Set;
+
+public class QueryBasedRelationInterpretationFactory implements PartialInterpretation.Factory<TruthValue, Boolean> {
+        private final Query<Boolean> may;
+        private final Query<Boolean> must;
+        private final Query<Boolean> candidateMay;
+        private final Query<Boolean> candidateMust;
+
+        public QueryBasedRelationInterpretationFactory(
+                        Query<Boolean> may, Query<Boolean> must, Query<Boolean> candidateMay, Query<Boolean> candidateMust) {
+                this.may = may;
+                this.must = must;
+                this.candidateMay = candidateMay;
+                this.candidateMust = candidateMust;
+        }
+
+        @Override
+        public PartialInterpretation<TruthValue, Boolean> create(
+                        ReasoningAdapter adapter, Concreteness concreteness, PartialSymbol<TruthValue, Boolean> partialSymbol) {
+                var queryEngine = adapter.getModel().getAdapter(ModelQueryAdapter.class);
+                ResultSet<Boolean> mayResultSet;
+                ResultSet<Boolean> mustResultSet;
+                switch (concreteness) {
+                case PARTIAL -> {
+                        mayResultSet = queryEngine.getResultSet(may);
+                        mustResultSet = queryEngine.getResultSet(must);
+                }
+                case CANDIDATE -> {
+                        mayResultSet = queryEngine.getResultSet(candidateMay);
+                        mustResultSet = queryEngine.getResultSet(candidateMust);
+                }
+                default -> throw new IllegalArgumentException("Unknown concreteness: " + concreteness);
+                }
+                if (mayResultSet.equals(mustResultSet)) {
+                        return new TwoValuedInterpretation(adapter, concreteness, partialSymbol, mustResultSet);
+                } else {
+                        return new FourValuedInterpretation(
+                                        adapter, concreteness, partialSymbol, mayResultSet, mustResultSet);
+                }
+        }
+
+        @Override
+        public void configure(ModelStoreBuilder storeBuilder, Set<Concreteness> requiredInterpretations) {
+                var queryBuilder = storeBuilder.getAdapter(ModelQueryBuilder.class);
+                if (requiredInterpretations.contains(Concreteness.PARTIAL)) {
+                        queryBuilder.queries(may, must);
+                }
+                if (requiredInterpretations.contains(Concreteness.CANDIDATE)) {
+                        queryBuilder.queries(candidateMay, candidateMust);
+                }
+        }
+
+        private static class TwoValuedInterpretation extends AbstractPartialInterpretation<TruthValue, Boolean> {
+                private final ResultSet<Boolean> resultSet;
+
+                protected TwoValuedInterpretation(
+                                ReasoningAdapter adapter, Concreteness concreteness, PartialSymbol<TruthValue, Boolean> partialSymbol,
+                                ResultSet<Boolean> resultSet) {
+                        super(adapter, concreteness, partialSymbol);
+                        this.resultSet = resultSet;
+                }
+
+                @Override
+                public TruthValue get(Tuple key) {
+                        return TruthValue.toTruthValue(resultSet.get(key));
+                }
+
+                @Override
+                public Cursor<Tuple, TruthValue> getAll() {
+                        return new TwoValuedCursor(resultSet.getAll());
+                }
+
+                private record TwoValuedCursor(Cursor<Tuple, Boolean> cursor) implements Cursor<Tuple, TruthValue> {
+                        @Override
+                        public Tuple getKey() {
+                                return cursor.getKey();
+                        }
+
+                        @Override
+                        public TruthValue getValue() {
+                                return TruthValue.toTruthValue(cursor.getValue());
+                        }
+
+                        @Override
+                        public boolean isTerminated() {
+                                return cursor.isTerminated();
+                        }
+
+                        @Override
+                        public boolean move() {
+                                return cursor.move();
+                        }
+                }
+        }
+
+        private static class FourValuedInterpretation extends AbstractPartialInterpretation<TruthValue, Boolean> {
+                private final ResultSet<Boolean> mayResultSet;
+                private final ResultSet<Boolean> mustResultSet;
+
+                public FourValuedInterpretation(
+                                ReasoningAdapter adapter, Concreteness concreteness, PartialSymbol<TruthValue, Boolean> partialSymbol,
+                                ResultSet<Boolean> mayResultSet, ResultSet<Boolean> mustResultSet) {
+                        super(adapter, concreteness, partialSymbol);
+                        this.mayResultSet = mayResultSet;
+                        this.mustResultSet = mustResultSet;
+                }
+
+                @Override
+                public TruthValue get(Tuple key) {
+                        boolean isMay = mayResultSet.get(key);
+                        boolean isMust = mustResultSet.get(key);
+                        if (isMust) {
+                                return isMay ? TruthValue.TRUE : TruthValue.ERROR;
+                        } else {
+                                return isMay ? TruthValue.UNKNOWN : TruthValue.FALSE;
+                        }
+                }
+
+                @Override
+                public Cursor<Tuple, TruthValue> getAll() {
+                        return new FourValuedCursor();
+                }
+
+                private final class FourValuedCursor implements Cursor<Tuple, TruthValue> {
+                        private final Cursor<Tuple, Boolean> mayCursor;
+                        private Cursor<Tuple, Boolean> mustCursor;
+
+                        private FourValuedCursor() {
+                                this.mayCursor = mayResultSet.getAll();
+                        }
+
+                        @Override
+                        public Tuple getKey() {
+                                return mustCursor == null ? mayCursor.getKey() : mustCursor.getKey();
+                        }
+
+                        @Override
+                        public TruthValue getValue() {
+                                if (mustCursor != null) {
+                                        return TruthValue.ERROR;
+                                }
+                                if (Boolean.TRUE.equals(mustResultSet.get(mayCursor.getKey()))) {
+                                        return TruthValue.TRUE;
+                                }
+                                return TruthValue.UNKNOWN;
+                        }
+
+                        @Override
+                        public boolean isTerminated() {
+                                return mustCursor != null && mustCursor.isTerminated();
+                        }
+
+                        @Override
+                        public boolean move() {
+                                if (mayCursor.isTerminated()) {
+                                        return moveMust();
+                                }
+                                if (mayCursor.move()) {
+                                        return true;
+                                }
+                                mustCursor = mustResultSet.getAll();
+                                return moveMust();
+                        }
+
+                        private boolean moveMust() {
+                                while (mustCursor.move()) {
+                                        // We already iterated over {@code TRUE} truth values with {@code mayCursor}.
+                                        if (!Boolean.TRUE.equals(mayResultSet.get(mustCursor.getKey()))) {
+                                                return true;
+                                        }
+                                }
+                                return false;
+                        }
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/QueryBasedRelationRewriter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/QueryBasedRelationRewriter.java
new file mode 100644
index 00000000..78fdbb89
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/QueryBasedRelationRewriter.java
@@ -0,0 +1,63 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.interpretation;
+
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.literal.AbstractCallLiteral;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.literal.Modality;
+
+import java.util.List;
+import java.util.Set;
+
+public class QueryBasedRelationRewriter implements PartialRelationRewriter {
+        private final RelationalQuery may;
+        private final RelationalQuery must;
+        private final RelationalQuery candidateMay;
+        private final RelationalQuery candidateMust;
+
+        public QueryBasedRelationRewriter(RelationalQuery may, RelationalQuery must, RelationalQuery candidateMay,
+                                                                          RelationalQuery candidateMust) {
+                this.may = may;
+                this.must = must;
+                this.candidateMay = candidateMay;
+                this.candidateMust = candidateMust;
+        }
+
+        public RelationalQuery getMay() {
+                return may;
+        }
+
+        public RelationalQuery getMust() {
+                return must;
+        }
+
+        public RelationalQuery getCandidateMay() {
+                return candidateMay;
+        }
+
+        public RelationalQuery getCandidateMust() {
+                return candidateMust;
+        }
+
+        @Override
+        public List<Literal> rewriteLiteral(Set<Variable> positiveVariables, AbstractCallLiteral literal,
+                                                                                Modality modality, Concreteness concreteness) {
+                var query = switch (concreteness) {
+                        case PARTIAL -> switch (modality) {
+                                case MAY -> may;
+                                case MUST -> must;
+                        };
+                        case CANDIDATE -> switch (modality) {
+                                case MAY -> candidateMay;
+                                case MUST -> candidateMust;
+                        };
+                };
+                return List.of(literal.withTarget(query.getDnf()));
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/ClauseLifter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/ClauseLifter.java
new file mode 100644
index 00000000..17916c02
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/ClauseLifter.java
@@ -0,0 +1,182 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.lifting;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.DnfClause;
+import tools.refinery.store.query.literal.*;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.query.term.ParameterDirection;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.literal.ModalConstraint;
+import tools.refinery.store.reasoning.literal.Modality;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+class ClauseLifter {
+        private final Modality modality;
+        private final Concreteness concreteness;
+        private final DnfClause clause;
+        private final Set<NodeVariable> quantifiedVariables;
+        private final Set<NodeVariable> existentialQuantifiersToAdd;
+
+        public ClauseLifter(Modality modality, Concreteness concreteness, Dnf dnf, DnfClause clause) {
+                this.modality = modality;
+                this.concreteness = concreteness;
+                this.clause = clause;
+                quantifiedVariables = getQuantifiedNodeVariables(dnf, clause);
+                existentialQuantifiersToAdd = new LinkedHashSet<>(quantifiedVariables);
+        }
+
+        private static Set<NodeVariable> getQuantifiedNodeVariables(Dnf dnf, DnfClause clause) {
+                var quantifiedVariables = clause.positiveVariables().stream()
+                                .filter(Variable::isNodeVariable)
+                                .map(Variable::asNodeVariable)
+                                .collect(Collectors.toCollection(LinkedHashSet::new));
+                for (var symbolicParameter : dnf.getSymbolicParameters()) {
+                        if (symbolicParameter.getVariable() instanceof NodeVariable nodeParameter) {
+                                quantifiedVariables.remove(nodeParameter);
+                        }
+                }
+                return Collections.unmodifiableSet(quantifiedVariables);
+        }
+
+        public List<Literal> liftClause() {
+                var liftedLiterals = new ArrayList<Literal>();
+                for (var literal : clause.literals()) {
+                        var liftedLiteral = liftLiteral(literal);
+                        liftedLiterals.add(liftedLiteral);
+                }
+                var existsConstraint = ModalConstraint.of(modality, concreteness, ReasoningAdapter.EXISTS_SYMBOL);
+                for (var quantifiedVariable : existentialQuantifiersToAdd) {
+                        liftedLiterals.add(existsConstraint.call(quantifiedVariable));
+                }
+                return liftedLiterals;
+        }
+
+        private Literal liftLiteral(Literal literal) {
+                if (literal instanceof CallLiteral callLiteral) {
+                        return liftCallLiteral(callLiteral);
+                } else if (literal instanceof EquivalenceLiteral equivalenceLiteral) {
+                        return liftEquivalenceLiteral(equivalenceLiteral);
+                } else if (literal instanceof ConstantLiteral ||
+                                literal instanceof AssignLiteral<?> ||
+                                literal instanceof CheckLiteral) {
+                        return literal;
+                } else if (literal instanceof AbstractCountLiteral<?>) {
+                        throw new IllegalArgumentException("Count literal %s cannot be lifted".formatted(literal));
+                } else if (literal instanceof AggregationLiteral<?, ?>) {
+                        throw new IllegalArgumentException("Aggregation literal %s cannot be lifted".formatted(literal));
+                } else if (literal instanceof RepresentativeElectionLiteral) {
+                        throw new IllegalArgumentException("SCC literal %s cannot be lifted".formatted(literal));
+                } else {
+                        throw new IllegalArgumentException("Unknown literal to lift: " + literal);
+                }
+        }
+
+        private Literal liftCallLiteral(CallLiteral callLiteral) {
+                var polarity = callLiteral.getPolarity();
+                return switch (polarity) {
+                        case POSITIVE -> {
+                                Constraint target = callLiteral.getTarget();
+                                var arguments = callLiteral.getArguments();
+                                yield ModalConstraint.of(modality, concreteness, target).call(CallPolarity.POSITIVE, arguments);
+                        }
+                        case NEGATIVE -> callNegationHelper(callLiteral);
+                        case TRANSITIVE -> callTransitiveHelper(callLiteral);
+                };
+        }
+
+        private Literal callNegationHelper(CallLiteral callLiteral) {
+                var target = callLiteral.getTarget();
+                var originalArguments = callLiteral.getArguments();
+                var negatedModality = modality.negate();
+                var privateVariables = callLiteral.getPrivateVariables(clause.positiveVariables());
+                if (privateVariables.isEmpty()) {
+                        // If there is no universal quantification, we may directly call the original Dnf.
+                        return ModalConstraint.of(negatedModality, concreteness, target)
+                                        .call(CallPolarity.NEGATIVE, originalArguments);
+                }
+
+                var builder = Dnf.builder("%s#negation#%s#%s#%s"
+                                .formatted(target.name(), modality, concreteness, privateVariables));
+                var uniqueOriginalArguments = List.copyOf(new LinkedHashSet<>(originalArguments));
+
+                var alwaysInputVariables = callLiteral.getInputVariables(Set.of());
+                for (var variable : uniqueOriginalArguments) {
+                        var direction = alwaysInputVariables.contains(variable) ? ParameterDirection.IN : ParameterDirection.OUT;
+                        builder.parameter(variable, direction);
+                }
+
+                var literals = new ArrayList<Literal>();
+                var liftedConstraint = ModalConstraint.of(negatedModality, concreteness, target);
+                literals.add(liftedConstraint.call(CallPolarity.POSITIVE, originalArguments));
+
+                var existsConstraint = ModalConstraint.of(negatedModality, concreteness, ReasoningAdapter.EXISTS_SYMBOL);
+                for (var variable : uniqueOriginalArguments) {
+                        if (privateVariables.contains(variable)) {
+                                literals.add(existsConstraint.call(variable));
+                        }
+                }
+
+                builder.clause(literals);
+                var liftedTarget = builder.build();
+                return liftedTarget.call(CallPolarity.NEGATIVE, uniqueOriginalArguments);
+        }
+
+        private Literal callTransitiveHelper(CallLiteral callLiteral) {
+                var target = callLiteral.getTarget();
+                var originalArguments = callLiteral.getArguments();
+                var liftedTarget = ModalConstraint.of(modality, concreteness, target);
+
+                var existsConstraint = ModalConstraint.of(modality, concreteness, ReasoningAdapter.EXISTS_SYMBOL);
+                var existingEndHelperName = "%s#exisitingEnd#%s#%s".formatted(target.name(), modality, concreteness);
+                var existingEndHelper = Dnf.of(existingEndHelperName, builder -> {
+                        var start = builder.parameter("start");
+                        var end = builder.parameter("end");
+                        builder.clause(
+                                        liftedTarget.call(start, end),
+                                        existsConstraint.call(end)
+                        );
+                });
+
+                // The start and end of a transitive path is always a node.
+                var pathEnd = (NodeVariable) originalArguments.get(1);
+                if (quantifiedVariables.contains(pathEnd)) {
+                        // The end of the path needs existential quantification anyway, so we don't need a second helper.
+                        // We replace the call to EXISTS with the transitive path call.
+                        existentialQuantifiersToAdd.remove(pathEnd);
+                        return existingEndHelper.call(CallPolarity.TRANSITIVE, originalArguments);
+                }
+
+                var transitiveHelperName = "%s#transitive#%s#%s".formatted(target.name(), modality, concreteness);
+                var transitiveHelper = Dnf.of(transitiveHelperName, builder -> {
+                        var start = builder.parameter("start");
+                        var end = builder.parameter("end");
+                        // Make sure the end of the path is not existentially quantified.
+                        builder.clause(liftedTarget.call(start, end));
+                        builder.clause(middle -> List.of(
+                                        existingEndHelper.callTransitive(start, middle),
+                                        liftedTarget.call(middle, end)
+                        ));
+                });
+
+                return transitiveHelper.call(CallPolarity.POSITIVE, originalArguments);
+        }
+
+        private Literal liftEquivalenceLiteral(EquivalenceLiteral equivalenceLiteral) {
+                if (equivalenceLiteral.isPositive()) {
+                        return ModalConstraint.of(modality, concreteness, ReasoningAdapter.EQUALS_SYMBOL)
+                                        .call(CallPolarity.POSITIVE, equivalenceLiteral.getLeft(), equivalenceLiteral.getRight());
+                }
+                return ModalConstraint.of(modality.negate(), concreteness, ReasoningAdapter.EQUALS_SYMBOL)
+                                .call(CallPolarity.NEGATIVE, equivalenceLiteral.getLeft(), equivalenceLiteral.getRight());
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/DnfLifter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/DnfLifter.java
index ac41d170..889f595f 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/DnfLifter.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/DnfLifter.java
@@ -5,124 +5,68 @@
  */
 package tools.refinery.store.reasoning.lifting;
 
-import org.jetbrains.annotations.Nullable;
-import tools.refinery.store.query.dnf.Dnf;
-import tools.refinery.store.query.dnf.DnfBuilder;
-import tools.refinery.store.query.dnf.DnfClause;
-import tools.refinery.store.query.literal.CallLiteral;
-import tools.refinery.store.query.literal.CallPolarity;
+import tools.refinery.store.query.dnf.*;
+import tools.refinery.store.query.equality.DnfEqualityChecker;
 import tools.refinery.store.query.literal.Literal;
-import tools.refinery.store.query.term.NodeVariable;
-import tools.refinery.store.query.term.Variable;
-import tools.refinery.store.reasoning.ReasoningAdapter;
-import tools.refinery.store.reasoning.literal.ModalConstraint;
+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.util.CycleDetectingMapper;
 
-import java.util.ArrayList;
-import java.util.LinkedHashSet;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 public class DnfLifter {
-        private final CycleDetectingMapper<ModalDnf, Dnf> mapper = new CycleDetectingMapper<>(ModalDnf::toString,
-                        this::doLift);
+        private final Map<ModalDnf, Dnf> cache = new HashMap<>();
 
-        public Dnf lift(Modality modality, Dnf query) {
-                return mapper.map(new ModalDnf(modality, query));
+        public <T> Query<T> lift(Modality modality, Concreteness concreteness, Query<T> query) {
+                var liftedDnf = lift(modality, concreteness, query.getDnf());
+                return query.withDnf(liftedDnf);
+        }
+
+        public RelationalQuery lift(Modality modality, Concreteness concreteness, RelationalQuery query) {
+                var liftedDnf = lift(modality, concreteness, query.getDnf());
+                return query.withDnf(liftedDnf);
+        }
+
+        public <T> FunctionalQuery<T> lift(Modality modality, Concreteness concreteness, FunctionalQuery<T> query) {
+                var liftedDnf = lift(modality, concreteness, query.getDnf());
+                return query.withDnf(liftedDnf);
+        }
+
+        public Dnf lift(Modality modality, Concreteness concreteness, Dnf dnf) {
+                return cache.computeIfAbsent(new ModalDnf(modality, concreteness, dnf), this::doLift);
         }
 
         private Dnf doLift(ModalDnf modalDnf) {
                 var modality = modalDnf.modality();
+                var concreteness = modalDnf.concreteness();
                 var dnf = modalDnf.dnf();
-                var builder = Dnf.builder();
+                var builder = Dnf.builder(decorateName(dnf.name(), modality, concreteness));
                 builder.symbolicParameters(dnf.getSymbolicParameters());
-                boolean changed = false;
+                builder.functionalDependencies(dnf.getFunctionalDependencies());
                 for (var clause : dnf.getClauses()) {
-                        if (liftClause(modality, dnf, clause, builder)) {
-                                changed = true;
-                        }
+                        builder.clause(liftClause(modality, concreteness, dnf, clause));
                 }
-                if (changed) {
-                        return builder.build();
+                var liftedDnf = builder.build();
+                if (dnf.equalsWithSubstitution(DnfEqualityChecker.DEFAULT, liftedDnf)) {
+                        return dnf;
                 }
-                return dnf;
+                return liftedDnf;
         }
 
-        private boolean liftClause(Modality modality, Dnf originalDnf, DnfClause clause, DnfBuilder builder) {
-                boolean changed = false;
-                var quantifiedVariables = getQuantifiedDataVariables(originalDnf, clause);
-                var literals = clause.literals();
-                var liftedLiterals = new ArrayList<Literal>(literals.size());
-                for (var literal : literals) {
-                        Literal liftedLiteral = liftLiteral(modality, literal);
-                        if (liftedLiteral == null) {
-                                liftedLiteral = literal;
-                        } else {
-                                changed = true;
-                        }
-                        liftedLiterals.add(liftedLiteral);
-                        var variable = isExistsLiteralForVariable(modality, liftedLiteral);
-                        if (variable != null) {
-                                // If we already quantify over the existence of the variable with the expected modality,
-                                // we don't need to insert quantification manually.
-                                quantifiedVariables.remove(variable);
-                        }
-                }
-                for (var quantifiedVariable : quantifiedVariables) {
-                        // Quantify over data variables that are not already quantified with the expected modality.
-                        liftedLiterals.add(new CallLiteral(CallPolarity.POSITIVE,
-                                        new ModalConstraint(modality, ReasoningAdapter.EXISTS), List.of(quantifiedVariable)));
-                }
-                builder.clause(liftedLiterals);
-                return changed || !quantifiedVariables.isEmpty();
-        }
-
-        private static LinkedHashSet<Variable> getQuantifiedDataVariables(Dnf originalDnf, DnfClause clause) {
-                var quantifiedVariables = new LinkedHashSet<>(clause.positiveVariables());
-                for (var symbolicParameter : originalDnf.getSymbolicParameters()) {
-                        // The existence of parameters will be checked outside this DNF.
-                        quantifiedVariables.remove(symbolicParameter.getVariable());
-                }
-                quantifiedVariables.removeIf(variable -> !(variable instanceof NodeVariable));
-                return quantifiedVariables;
+        private List<Literal> liftClause(Modality modality, Concreteness concreteness, Dnf dnf, DnfClause clause) {
+                var lifter = new ClauseLifter(modality, concreteness, dnf, clause);
+                return lifter.liftClause();
         }
 
-        @Nullable
-        private Variable isExistsLiteralForVariable(Modality modality, Literal literal) {
-                if (literal instanceof CallLiteral callLiteral &&
-                                callLiteral.getPolarity() == CallPolarity.POSITIVE &&
-                                callLiteral.getTarget() instanceof ModalConstraint modalConstraint &&
-                                modalConstraint.modality() == modality &&
-                                modalConstraint.constraint().equals(ReasoningAdapter.EXISTS)) {
-                        return callLiteral.getArguments().get(0);
+        private record ModalDnf(Modality modality, Concreteness concreteness, Dnf dnf) {
+                @Override
+                public String toString() {
+                        return "%s %s %s".formatted(modality, concreteness, dnf.name());
                 }
-                return null;
         }
 
-        @Nullable
-        private Literal liftLiteral(Modality modality, Literal literal) {
-                if (!(literal instanceof CallLiteral callLiteral)) {
-                        return null;
-                }
-                var target = callLiteral.getTarget();
-                if (target instanceof ModalConstraint modalTarget) {
-                        var actualTarget = modalTarget.constraint();
-                        if (actualTarget instanceof Dnf dnf) {
-                                var targetModality = modalTarget.modality();
-                                var liftedTarget = lift(targetModality, dnf);
-                                return new CallLiteral(callLiteral.getPolarity(), liftedTarget, callLiteral.getArguments());
-                        }
-                        // No more lifting to be done, pass any modal call to a partial symbol through.
-                        return null;
-                } else if (target instanceof Dnf dnf) {
-                        var polarity = callLiteral.getPolarity();
-                        var liftedTarget = lift(modality.commute(polarity), dnf);
-                        // Use == instead of equals(), because lift will return the same object by reference is there are no
-                        // changes made during lifting.
-                        return liftedTarget == target ? null : new CallLiteral(polarity, liftedTarget, callLiteral.getArguments());
-                } else {
-                        return PartialLiterals.addModality(callLiteral, modality);
-                }
+        public static String decorateName(String name, Modality modality, Concreteness concreteness) {
+                return "%s#%s#%s".formatted(name, modality, concreteness);
         }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/ModalDnf.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/ModalDnf.java
deleted file mode 100644
index 16fb8fbf..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/ModalDnf.java
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.lifting;
-
-import tools.refinery.store.query.dnf.Dnf;
-import tools.refinery.store.reasoning.literal.Modality;
-
-record ModalDnf(Modality modality, Dnf dnf) {
-        @Override
-        public String toString() {
-                return "%s %s".formatted(modality, dnf.name());
-        }
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/Concreteness.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/Concreteness.java
new file mode 100644
index 00000000..43ac5904
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/Concreteness.java
@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.literal;
+
+import java.util.Locale;
+
+public enum Concreteness {
+        PARTIAL,
+        CANDIDATE;
+
+        @Override
+        public String toString() {
+                return name().toLowerCase(Locale.ROOT);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/CountCandidateLowerBoundLiteral.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/CountCandidateLowerBoundLiteral.java
new file mode 100644
index 00000000..91dd2b72
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/CountCandidateLowerBoundLiteral.java
@@ -0,0 +1,49 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.literal;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.literal.AbstractCallLiteral;
+import tools.refinery.store.query.literal.AbstractCountLiteral;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.List;
+
+public class CountCandidateLowerBoundLiteral extends AbstractCountLiteral<Integer> {
+        public CountCandidateLowerBoundLiteral(DataVariable<Integer> resultVariable, Constraint target,
+                                                                                   List<Variable> arguments) {
+                super(Integer.class, resultVariable, target, arguments);
+        }
+
+        @Override
+        protected Integer zero() {
+                return 0;
+        }
+
+        @Override
+        protected Integer one() {
+                return 1;
+        }
+
+        @Override
+        protected Literal doSubstitute(Substitution substitution, List<Variable> substitutedArguments) {
+                return new CountCandidateLowerBoundLiteral(substitution.getTypeSafeSubstitute(getResultVariable()), getTarget(),
+                                substitutedArguments);
+        }
+
+        @Override
+        public AbstractCallLiteral withArguments(Constraint newTarget, List<Variable> newArguments) {
+                return new CountCandidateLowerBoundLiteral(getResultVariable(), newTarget, newArguments);
+        }
+
+        @Override
+        protected String operatorName() {
+                return "@LowerBound(\"candidate\") count";
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/CountCandidateUpperBoundLiteral.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/CountCandidateUpperBoundLiteral.java
new file mode 100644
index 00000000..94c9399d
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/CountCandidateUpperBoundLiteral.java
@@ -0,0 +1,49 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.literal;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.literal.AbstractCallLiteral;
+import tools.refinery.store.query.literal.AbstractCountLiteral;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.List;
+
+public class CountCandidateUpperBoundLiteral extends AbstractCountLiteral<Integer> {
+        public CountCandidateUpperBoundLiteral(DataVariable<Integer> resultVariable, Constraint target,
+                                                                                   List<Variable> arguments) {
+                super(Integer.class, resultVariable, target, arguments);
+        }
+
+        @Override
+        protected Integer zero() {
+                return 0;
+        }
+
+        @Override
+        protected Integer one() {
+                return 1;
+        }
+
+        @Override
+        protected Literal doSubstitute(Substitution substitution, List<Variable> substitutedArguments) {
+                return new CountCandidateUpperBoundLiteral(substitution.getTypeSafeSubstitute(getResultVariable()), getTarget(),
+                                substitutedArguments);
+        }
+
+        @Override
+        public AbstractCallLiteral withArguments(Constraint newTarget, List<Variable> newArguments) {
+                return new CountCandidateUpperBoundLiteral(getResultVariable(), newTarget, newArguments);
+        }
+
+        @Override
+        protected String operatorName() {
+                return "@UpperBound(\"candidate\") count";
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/CountLowerBoundLiteral.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/CountLowerBoundLiteral.java
new file mode 100644
index 00000000..b75b0cab
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/CountLowerBoundLiteral.java
@@ -0,0 +1,49 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.literal;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.literal.AbstractCallLiteral;
+import tools.refinery.store.query.literal.AbstractCountLiteral;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.List;
+
+public class CountLowerBoundLiteral extends AbstractCountLiteral<Integer> {
+        public CountLowerBoundLiteral(DataVariable<Integer> resultVariable, Constraint target,
+                                                                  List<Variable> arguments) {
+                super(Integer.class, resultVariable, target, arguments);
+        }
+
+        @Override
+        protected Integer zero() {
+                return 0;
+        }
+
+        @Override
+        protected Integer one() {
+                return 1;
+        }
+
+        @Override
+        protected Literal doSubstitute(Substitution substitution, List<Variable> substitutedArguments) {
+                return new CountLowerBoundLiteral(substitution.getTypeSafeSubstitute(getResultVariable()), getTarget(),
+                                substitutedArguments);
+        }
+
+        @Override
+        public AbstractCallLiteral withArguments(Constraint newTarget, List<Variable> newArguments) {
+                return new CountLowerBoundLiteral(getResultVariable(), newTarget, newArguments);
+        }
+
+        @Override
+        protected String operatorName() {
+                return "@LowerBound(\"partial\") count";
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/CountUpperBoundLiteral.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/CountUpperBoundLiteral.java
new file mode 100644
index 00000000..03842143
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/CountUpperBoundLiteral.java
@@ -0,0 +1,51 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.literal;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.literal.AbstractCallLiteral;
+import tools.refinery.store.query.literal.AbstractCountLiteral;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.representation.cardinality.UpperCardinalities;
+import tools.refinery.store.representation.cardinality.UpperCardinality;
+
+import java.util.List;
+
+public class CountUpperBoundLiteral extends AbstractCountLiteral<UpperCardinality> {
+        public CountUpperBoundLiteral(DataVariable<UpperCardinality> resultVariable, Constraint target,
+                                                                  List<Variable> arguments) {
+                super(UpperCardinality.class, resultVariable, target, arguments);
+        }
+
+        @Override
+        protected UpperCardinality zero() {
+                return UpperCardinalities.ZERO;
+        }
+
+        @Override
+        protected UpperCardinality one() {
+                return UpperCardinalities.UNBOUNDED;
+        }
+
+        @Override
+        protected Literal doSubstitute(Substitution substitution, List<Variable> substitutedArguments) {
+                return new CountUpperBoundLiteral(substitution.getTypeSafeSubstitute(getResultVariable()), getTarget(),
+                                substitutedArguments);
+        }
+
+        @Override
+        public AbstractCallLiteral withArguments(Constraint newTarget, List<Variable> newArguments) {
+                return new CountUpperBoundLiteral(getResultVariable(), newTarget, newArguments);
+        }
+
+        @Override
+        protected String operatorName() {
+                return "@UpperBound(\"partial\") count";
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java
index 4e5a6099..2235a95d 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java
@@ -6,18 +6,29 @@
 package tools.refinery.store.reasoning.literal;
 
 import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.equality.LiteralEqualityHelper;
 import tools.refinery.store.query.literal.Reduction;
 import tools.refinery.store.query.term.Parameter;
+import tools.refinery.store.query.view.AnySymbolView;
 
 import java.util.List;
 
-public record ModalConstraint(Modality modality, Constraint constraint) implements Constraint {
-        private static final String FORMAT = "%s %s";
+public record ModalConstraint(Modality modality, Concreteness concreteness, Constraint constraint)
+                implements Constraint {
+        public ModalConstraint {
+                if (constraint instanceof AnySymbolView || constraint instanceof ModalConstraint) {
+                        throw new InvalidQueryException("Already concrete constraints cannot be abstracted");
+                }
+        }
+
+        public ModalConstraint(Modality modality, Constraint constraint) {
+                this(modality, Concreteness.PARTIAL, constraint);
+        }
 
         @Override
         public String name() {
-                return FORMAT.formatted(modality, constraint.name());
+                return formatName(constraint.name());
         }
 
         @Override
@@ -36,16 +47,33 @@ public record ModalConstraint(Modality modality, Constraint constraint) implemen
                         return false;
                 }
                 var otherModalConstraint = (ModalConstraint) other;
-                return modality == otherModalConstraint.modality && constraint.equals(helper, otherModalConstraint.constraint);
+                return modality == otherModalConstraint.modality &&
+                                concreteness == otherModalConstraint.concreteness &&
+                                constraint.equals(helper, otherModalConstraint.constraint);
         }
 
         @Override
         public String toReferenceString() {
-                return FORMAT.formatted(modality, constraint.toReferenceString());
+                return formatName(constraint.toReferenceString());
         }
 
         @Override
         public String toString() {
-                return FORMAT.formatted(modality, constraint);
+                return formatName(constraint.toString());
+        }
+
+        private String formatName(String constraintName) {
+                if (concreteness == Concreteness.PARTIAL) {
+                        return "%s %s".formatted(modality, constraintName);
+                }
+                return "%s %s %s".formatted(modality, concreteness, constraintName);
+        }
+
+        public static Constraint of(Modality modality, Concreteness concreteness, Constraint constraint) {
+                if (constraint instanceof AnySymbolView || constraint instanceof ModalConstraint) {
+                        // Symbol views and lifted constraints are already concrete. Thus, they cannot be abstracted at all.
+                        return constraint;
+                }
+                return new ModalConstraint(modality, concreteness, constraint);
         }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/Modality.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/Modality.java
index 96466d5c..c99a0399 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/Modality.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/Modality.java
@@ -11,14 +11,12 @@ import java.util.Locale;
 
 public enum Modality {
         MUST,
-        MAY,
-        CURRENT;
+        MAY;
 
         public Modality negate() {
                 return switch(this) {
                         case MUST -> MAY;
                         case MAY -> MUST;
-                        case CURRENT -> CURRENT;
                 };
         }
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java
index 0e46a795..2614c26e 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.reasoning.literal;
 
+import tools.refinery.store.query.InvalidQueryException;
 import tools.refinery.store.query.literal.CallLiteral;
 
 public final class PartialLiterals {
@@ -13,24 +14,28 @@ public final class PartialLiterals {
         }
 
         public static CallLiteral may(CallLiteral literal) {
-                return addModality(literal, Modality.MAY);
+                return addModality(literal, Modality.MAY, Concreteness.PARTIAL);
         }
 
         public static CallLiteral must(CallLiteral literal) {
-                return addModality(literal, Modality.MUST);
+                return addModality(literal, Modality.MUST, Concreteness.PARTIAL);
         }
 
-        public static CallLiteral current(CallLiteral literal) {
-                return addModality(literal, Modality.CURRENT);
+        public static CallLiteral candidateMay(CallLiteral literal) {
+                return addModality(literal, Modality.MAY, Concreteness.CANDIDATE);
         }
 
-        public static CallLiteral addModality(CallLiteral literal, Modality modality) {
+        public static CallLiteral candidateMust(CallLiteral literal) {
+                return addModality(literal, Modality.MUST, Concreteness.CANDIDATE);
+        }
+
+        public static CallLiteral addModality(CallLiteral literal, Modality modality, Concreteness concreteness) {
                 var target = literal.getTarget();
                 if (target instanceof ModalConstraint) {
-                        throw new IllegalArgumentException("Literal %s already has modality".formatted(literal));
+                        throw new InvalidQueryException("Literal %s already has modality".formatted(literal));
                 }
                 var polarity = literal.getPolarity();
-                var modalTarget = new ModalConstraint(modality.commute(polarity), target);
+                var modalTarget = new ModalConstraint(modality.commute(polarity), concreteness, target);
                 return new CallLiteral(polarity, modalTarget, literal.getArguments());
         }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/AbstractPartialInterpretationRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/AbstractPartialInterpretationRefiner.java
new file mode 100644
index 00000000..a7fc5b7e
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/AbstractPartialInterpretationRefiner.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.refinement;
+
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+
+public abstract class AbstractPartialInterpretationRefiner<A, C> implements PartialInterpretationRefiner<A, C> {
+        private final ReasoningAdapter adapter;
+        private final PartialSymbol<A, C> partialSymbol;
+
+        protected AbstractPartialInterpretationRefiner(ReasoningAdapter adapter, PartialSymbol<A, C> partialSymbol) {
+                this.adapter = adapter;
+                this.partialSymbol = partialSymbol;
+        }
+
+        @Override
+        public ReasoningAdapter getAdapter() {
+                return adapter;
+        }
+
+        @Override
+        public PartialSymbol<A, C> getPartialSymbol() {
+                return partialSymbol;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/AnyPartialInterpretationRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/AnyPartialInterpretationRefiner.java
new file mode 100644
index 00000000..6c381511
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/AnyPartialInterpretationRefiner.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.refinement;
+
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+
+public sealed interface AnyPartialInterpretationRefiner permits PartialInterpretationRefiner {
+        ReasoningAdapter getAdapter();
+
+        AnyPartialSymbol getPartialSymbol();
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/ConcreteSymbolRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/ConcreteSymbolRefiner.java
new file mode 100644
index 00000000..ebb9b824
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/ConcreteSymbolRefiner.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.refinement;
+
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Objects;
+
+public class ConcreteSymbolRefiner<A, C> extends AbstractPartialInterpretationRefiner<A, C> {
+        private final Interpretation<A> interpretation;
+
+        public ConcreteSymbolRefiner(ReasoningAdapter adapter, PartialSymbol<A, C> partialSymbol,
+                                                                 Symbol<A> concreteSymbol) {
+                super(adapter, partialSymbol);
+                interpretation = adapter.getModel().getInterpretation(concreteSymbol);
+        }
+
+        @Override
+        public boolean merge(Tuple key, A value) {
+                var currentValue = interpretation.get(key);
+                var mergedValue = getPartialSymbol().abstractDomain().commonRefinement(currentValue, value);
+                if (!Objects.equals(currentValue, mergedValue)) {
+                        interpretation.put(key, mergedValue);
+                }
+                return true;
+        }
+
+        public static <A1, C1> Factory<A1, C1> of(Symbol<A1> concreteSymbol) {
+                return (adapter, partialSymbol) -> new ConcreteSymbolRefiner<>(adapter, partialSymbol, concreteSymbol);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/DefaultStorageRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/DefaultStorageRefiner.java
new file mode 100644
index 00000000..d4ec2e8b
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/DefaultStorageRefiner.java
@@ -0,0 +1,79 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.refinement;
+
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+public class DefaultStorageRefiner<T> implements StorageRefiner {
+        private static final StorageRefiner.Factory<Object> FACTORY = DefaultStorageRefiner::new;
+
+        private final Interpretation<T> interpretation;
+
+        public DefaultStorageRefiner(Symbol<T> symbol, Model model) {
+                interpretation = model.getInterpretation(symbol);
+        }
+
+        @Override
+        public boolean split(int parentNode, int childNode) {
+                var symbol = interpretation.getSymbol();
+                int arity = symbol.arity();
+                for (int i = 0; i < arity; i++) {
+                        int adjacentSize = interpretation.getAdjacentSize(i, parentNode);
+                        if (adjacentSize == 0) {
+                                continue;
+                        }
+                        var toSetKeys = new Tuple[adjacentSize];
+                        // This is safe, because we won't pass the array to the outside.
+                        @SuppressWarnings("unchecked")
+                        var toSetValues = (T[]) new Object[adjacentSize];
+                        var cursor = interpretation.getAdjacent(i, parentNode);
+                        int j = 0;
+                        while (cursor.move()) {
+                                toSetKeys[j] = cursor.getKey().set(i, childNode);
+                                toSetValues[j] = cursor.getValue();
+                                j++;
+                        }
+                        for (j = 0; j < adjacentSize; j++) {
+                                interpretation.put(toSetKeys[j], toSetValues[j]);
+                        }
+                }
+                return true;
+        }
+
+        @Override
+        public boolean cleanup(int nodeToDelete) {
+                var symbol = interpretation.getSymbol();
+                int arity = symbol.arity();
+                var defaultValue = symbol.defaultValue();
+                for (int i = 0; i < arity; i++) {
+                        int adjacentSize = interpretation.getAdjacentSize(i, nodeToDelete);
+                        if (adjacentSize == 0) {
+                                continue;
+                        }
+                        var toDelete = new Tuple[adjacentSize];
+                        var cursor = interpretation.getAdjacent(i, nodeToDelete);
+                        int j = 0;
+                        while (cursor.move()) {
+                                toDelete[j] = cursor.getKey();
+                                j++;
+                        }
+                        for (j = 0; j < adjacentSize; j++) {
+                                interpretation.put(toDelete[j], defaultValue);
+                        }
+                }
+                return true;
+        }
+
+        public static <T> StorageRefiner.Factory<T> factory() {
+                // This is safe, because {@code FACTORY} doesn't depend on {@code T} at all.
+                @SuppressWarnings("unchecked")
+                var typedFactory = (StorageRefiner.Factory<T>) FACTORY;
+                return typedFactory;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/PartialInterpretationRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/PartialInterpretationRefiner.java
new file mode 100644
index 00000000..f48d1d1f
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/PartialInterpretationRefiner.java
@@ -0,0 +1,22 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.refinement;
+
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.tuple.Tuple;
+
+public non-sealed interface PartialInterpretationRefiner<A, C> extends AnyPartialInterpretationRefiner {
+        @Override
+        PartialSymbol<A, C> getPartialSymbol();
+
+        boolean merge(Tuple key, A value);
+
+        @FunctionalInterface
+        interface Factory<A, C> {
+                PartialInterpretationRefiner<A, C> create(ReasoningAdapter adapter, PartialSymbol<A, C> partialSymbol);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/PartialModelInitializer.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/PartialModelInitializer.java
new file mode 100644
index 00000000..0c82695c
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/PartialModelInitializer.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.refinement;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.seed.ModelSeed;
+
+@FunctionalInterface
+public interface PartialModelInitializer {
+        void initialize(Model model, ModelSeed modelSeed);
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/RefinementBasedInitializer.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/RefinementBasedInitializer.java
new file mode 100644
index 00000000..b6bccb01
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/RefinementBasedInitializer.java
@@ -0,0 +1,34 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.refinement;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.reasoning.seed.ModelSeed;
+
+public class RefinementBasedInitializer<A, C> implements PartialModelInitializer {
+        private final PartialSymbol<A, C> partialSymbol;
+
+        public RefinementBasedInitializer(PartialSymbol<A, C> partialSymbol) {
+                this.partialSymbol = partialSymbol;
+        }
+
+        @Override
+        public void initialize(Model model, ModelSeed modelSeed) {
+                var refiner = model.getAdapter(ReasoningAdapter.class).getRefiner(partialSymbol);
+                var defaultValue = partialSymbol.abstractDomain().unknown();
+                var cursor = modelSeed.getCursor(partialSymbol, defaultValue);
+                while (cursor.move()) {
+                        var key = cursor.getKey();
+                        var value = cursor.getValue();
+                        if (!refiner.merge(key, value)) {
+                                throw new IllegalArgumentException("Failed to merge value %s for key %s into %s"
+                                                .formatted(value, key, partialSymbol));
+                        }
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/StorageRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/StorageRefiner.java
new file mode 100644
index 00000000..004696fd
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/StorageRefiner.java
@@ -0,0 +1,20 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.refinement;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.representation.Symbol;
+
+public interface StorageRefiner {
+        boolean split(int parentNode, int childNode);
+
+        boolean cleanup(int nodeToDelete);
+
+        @FunctionalInterface
+        interface Factory<T> {
+                StorageRefiner create(Symbol<T> symbol, Model model);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialFunction.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialFunction.java
index d58d026f..e59c8af8 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialFunction.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialFunction.java
@@ -15,11 +15,6 @@ public record PartialFunction<A, C>(String name, int arity, AbstractDomain<A, C>
         }
 
         @Override
-        public C defaultConcreteValue() {
-                return null;
-        }
-
-        @Override
         public boolean equals(Object o) {
                 return this == o;
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialRelation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialRelation.java
index 6b2f050b..4ccb7033 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialRelation.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialRelation.java
@@ -26,11 +26,6 @@ public record PartialRelation(String name, int arity) implements PartialSymbol<T
         }
 
         @Override
-        public Boolean defaultConcreteValue() {
-                return false;
-        }
-
-        @Override
         public List<Parameter> getParameters() {
                 var parameters = new Parameter[arity];
                 Arrays.fill(parameters, Parameter.NODE_OUT);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialSymbol.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialSymbol.java
index 3a08bdd8..38b2e466 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialSymbol.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialSymbol.java
@@ -13,5 +13,11 @@ public sealed interface PartialSymbol<A, C> extends AnyPartialSymbol permits Par
 
         A defaultValue();
 
-        C defaultConcreteValue();
+        static PartialRelation of(String name, int arity) {
+                return new PartialRelation(name, arity);
+        }
+
+        static <A, C> PartialFunction<A, C> of(String name, int arity, AbstractDomain<A, C> abstractDomain) {
+                return new PartialFunction<>(name, arity, abstractDomain);
+        }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/MapBasedSeed.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/MapBasedSeed.java
new file mode 100644
index 00000000..8b1c3bb3
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/MapBasedSeed.java
@@ -0,0 +1,111 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.seed;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.Cursors;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Map;
+import java.util.Objects;
+
+record MapBasedSeed<T>(int arity, Class<T> valueType, T reducedValue, Map<Tuple, T> map) implements Seed<T> {
+        @Override
+        public T get(Tuple key) {
+                var value = map.get(key);
+                return value == null ? reducedValue : value;
+        }
+
+        @Override
+        public Cursor<Tuple, T> getCursor(T defaultValue, int nodeCount) {
+                if (Objects.equals(defaultValue, reducedValue)) {
+                        return Cursors.of(map);
+                }
+                return new CartesianProductCursor<>(arity, nodeCount, reducedValue, defaultValue, map);
+        }
+
+        private static class CartesianProductCursor<T> implements Cursor<Tuple, T> {
+                private final int nodeCount;
+                private final T reducedValue;
+                private final T defaultValue;
+                private final Map<Tuple, T> map;
+                private final int[] counter;
+                private State state = State.INITIAL;
+                private Tuple key;
+                private T value;
+
+                private CartesianProductCursor(int arity, int nodeCount, T reducedValue, T defaultValue, Map<Tuple, T> map) {
+                        this.nodeCount = nodeCount;
+                        this.reducedValue = reducedValue;
+                        this.defaultValue = defaultValue;
+                        this.map = map;
+                        counter = new int[arity];
+                }
+
+                @Override
+                public Tuple getKey() {
+                        return key;
+                }
+
+                @Override
+                public T getValue() {
+                        return value;
+                }
+
+                @Override
+                public boolean isTerminated() {
+                        return state == State.TERMINATED;
+                }
+
+                @Override
+                public boolean move() {
+                        return switch (state) {
+                                case INITIAL -> {
+                                        state = State.STARTED;
+                                        yield checkValue() || moveToNext();
+                                }
+                                case STARTED -> moveToNext();
+                                case TERMINATED -> false;
+                        };
+                }
+
+                private boolean moveToNext() {
+                        do {
+                                increment();
+                        } while (state != State.TERMINATED && !checkValue());
+                        return state != State.TERMINATED;
+                }
+
+                private void increment() {
+                        int i = counter.length - 1;
+                        while (i >= 0) {
+                                counter[i]++;
+                                if (counter[i] < nodeCount) {
+                                        return;
+                                }
+                                counter[i] = 0;
+                                i--;
+                        }
+                        state = State.TERMINATED;
+                }
+
+                private boolean checkValue() {
+                        key = Tuple.of(counter);
+                        var valueInMap = map.get(key);
+                        if (Objects.equals(valueInMap, defaultValue)) {
+                                return false;
+                        }
+                        value = valueInMap == null ? reducedValue : valueInMap;
+                        return true;
+                }
+
+                private enum State {
+                        INITIAL,
+                        STARTED,
+                        TERMINATED
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/ModelSeed.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/ModelSeed.java
new file mode 100644
index 00000000..e6b3eaf9
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/ModelSeed.java
@@ -0,0 +1,95 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.seed;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+
+public class ModelSeed {
+        private final int nodeCount;
+        private final Map<AnyPartialSymbol, Seed<?>> seeds;
+
+        private ModelSeed(int nodeCount, Map<AnyPartialSymbol, Seed<?>> seeds) {
+                this.nodeCount = nodeCount;
+                this.seeds = seeds;
+        }
+
+        public int getNodeCount() {
+                return nodeCount;
+        }
+
+        public <A> Seed<A> getSeed(PartialSymbol<A, ?> partialSymbol) {
+                var seed = seeds.get(partialSymbol);
+                if (seed == null) {
+                        throw new IllegalArgumentException("No seed for partial symbol " + partialSymbol);
+                }
+                // The builder makes sure only well-typed seeds can be added.
+                @SuppressWarnings("unchecked")
+                var typedSeed = (Seed<A>) seed;
+                return typedSeed;
+        }
+
+        public boolean containsSeed(AnyPartialSymbol symbol) {
+                return seeds.containsKey(symbol);
+        }
+
+        public Set<AnyPartialSymbol> getSeededSymbols() {
+                return Collections.unmodifiableSet(seeds.keySet());
+        }
+
+        public <A> Cursor<Tuple, A> getCursor(PartialSymbol<A, ?> partialSymbol, A defaultValue) {
+                return getSeed(partialSymbol).getCursor(defaultValue, nodeCount);
+        }
+
+        public static Builder builder(int nodeCount) {
+                return new Builder(nodeCount);
+        }
+
+        public static class Builder {
+                private final int nodeCount;
+                private final Map<AnyPartialSymbol, Seed<?>> seeds = new LinkedHashMap<>();
+
+                private Builder(int nodeCount) {
+                        if (nodeCount < 0) {
+                                throw new IllegalArgumentException("Node count must not be negative");
+                        }
+                        this.nodeCount = nodeCount;
+                }
+
+                public <A> Builder seed(PartialSymbol<A, ?> partialSymbol, Seed<A> seed) {
+                        if (seed.arity() != partialSymbol.arity()) {
+                                throw new IllegalStateException("Expected seed of arity %d for partial symbol %s, but got %d instead"
+                                                .formatted(partialSymbol.arity(), partialSymbol, seed.arity()));
+                        }
+                        if (!seed.valueType().equals(partialSymbol.abstractDomain().abstractType())) {
+                                throw new IllegalStateException("Expected seed of type %s for partial symbol %s, but got %s instead"
+                                                .formatted(partialSymbol.abstractDomain().abstractType(), partialSymbol, seed.valueType()));
+                        }
+                        if (seeds.put(partialSymbol, seed) != null) {
+                                throw new IllegalArgumentException("Duplicate seed for partial symbol " + partialSymbol);
+                        }
+                        return this;
+                }
+
+                public <A> Builder seed(PartialSymbol<A, ?> partialSymbol, Consumer<Seed.Builder<A>> callback) {
+                        var builder = Seed.builder(partialSymbol);
+                        callback.accept(builder);
+                        return seed(partialSymbol, builder.build());
+                }
+
+                public ModelSeed build() {
+                        return new ModelSeed(nodeCount, Collections.unmodifiableMap(seeds));
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java
index 08079f12..732efbcc 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java
@@ -6,14 +6,73 @@
 package tools.refinery.store.reasoning.seed;
 
 import tools.refinery.store.map.Cursor;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
 
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
 public interface Seed<T> {
         int arity();
 
+        Class<T> valueType();
+
         T reducedValue();
 
         T get(Tuple key);
 
         Cursor<Tuple, T> getCursor(T defaultValue, int nodeCount);
+
+        static <T> Builder<T> builder(int arity, Class<T> valueType, T reducedValue) {
+                return new Builder<>(arity, valueType, reducedValue);
+        }
+
+        static <T> Builder<T> builder(Symbol<T> symbol) {
+                return builder(symbol.arity(), symbol.valueType(), symbol.defaultValue());
+        }
+
+        static <T> Builder<T> builder(PartialSymbol<T, ?> partialSymbol) {
+                return builder(partialSymbol.arity(), partialSymbol.abstractDomain().abstractType(),
+                                partialSymbol.defaultValue());
+        }
+
+        @SuppressWarnings("UnusedReturnValue")
+        class Builder<T> {
+                private final int arity;
+                private final Class<T> valueType;
+                private T reducedValue;
+                private final Map<Tuple, T> map = new LinkedHashMap<>();
+
+                private Builder(int arity, Class<T> valueType, T reducedValue) {
+                        this.arity = arity;
+                        this.valueType = valueType;
+                        this.reducedValue = reducedValue;
+                }
+
+                public Builder<T> reducedValue(T reducedValue) {
+                        this.reducedValue = reducedValue;
+                        return this;
+                }
+
+                public Builder<T> put(Tuple key, T value) {
+                        if (key.getSize() != arity) {
+                                throw new IllegalArgumentException("Expected %s to have %d elements".formatted(key, arity));
+                        }
+                        map.put(key, value);
+                        return this;
+                }
+
+                public Builder<T> putAll(Map<Tuple, T> map) {
+                        for (var entry : map.entrySet()) {
+                                put(entry.getKey(), entry.getValue());
+                        }
+                        return this;
+                }
+
+                public Seed<T> build() {
+                        return new MapBasedSeed<>(arity, valueType, reducedValue, Collections.unmodifiableMap(map));
+                }
+        }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/SeedInitializer.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/SeedInitializer.java
new file mode 100644
index 00000000..9af457d8
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/SeedInitializer.java
@@ -0,0 +1,28 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.seed;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.representation.Symbol;
+
+public class SeedInitializer<T> implements PartialModelInitializer {
+        private final Symbol<T> symbol;
+        private final PartialSymbol<T, ?> partialSymbol;
+
+        public SeedInitializer(Symbol<T> symbol, PartialSymbol<T, ?> partialSymbol) {
+                this.symbol = symbol;
+                this.partialSymbol = partialSymbol;
+        }
+
+        @Override
+        public void initialize(Model model, ModelSeed modelSeed) {
+                var interpretation = model.getInterpretation(symbol);
+                var cursor = modelSeed.getCursor(partialSymbol, symbol.defaultValue());
+                interpretation.putAll(cursor);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/UniformSeed.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/UniformSeed.java
deleted file mode 100644
index 451d1513..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/UniformSeed.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.seed;
-
-import tools.refinery.store.map.Cursor;
-import tools.refinery.store.tuple.Tuple;
-
-public record UniformSeed<T>(int arity, T reducedValue) implements Seed<T> {
-        public UniformSeed {
-                if (arity < 0) {
-                        throw new IllegalArgumentException("Arity must not be negative");
-                }
-        }
-
-        @Override
-        public T get(Tuple key) {
-                return reducedValue;
-        }
-
-        @Override
-        public Cursor<Tuple, T> getCursor(T defaultValue, int nodeCount) {
-                return null;
-        }
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/Advice.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/Advice.java
deleted file mode 100644
index d6a9e02c..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/Advice.java
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.translator;
-
-import tools.refinery.store.query.substitution.Substitution;
-import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
-import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.query.term.Variable;
-import tools.refinery.store.query.literal.Literal;
-
-import java.util.*;
-
-public final class Advice {
-        private final AnyPartialSymbol source;
-        private final PartialRelation target;
-        private final AdviceSlot slot;
-        private final boolean mandatory;
-        private final List<Variable> parameters;
-        private final List<Literal> literals;
-        private boolean processed;
-
-        public Advice(AnyPartialSymbol source, PartialRelation target, AdviceSlot slot, boolean mandatory, List<Variable> parameters, List<Literal> literals) {
-                if (mandatory && !slot.isMonotonic()) {
-                        throw new IllegalArgumentException("Only monotonic advice can be mandatory");
-                }
-                this.source = source;
-                this.target = target;
-                this.slot = slot;
-                this.mandatory = mandatory;
-                checkArity(parameters);
-                this.parameters = parameters;
-                this.literals = literals;
-        }
-
-        public AnyPartialSymbol source() {
-                return source;
-        }
-
-        public PartialRelation target() {
-                return target;
-        }
-
-        public AdviceSlot slot() {
-                return slot;
-        }
-
-        public boolean mandatory() {
-                return mandatory;
-        }
-
-        public List<Variable> parameters() {
-                return parameters;
-        }
-
-        public List<Literal> literals() {
-                return literals;
-        }
-
-        public boolean processed() {
-                return processed;
-        }
-
-        public List<Literal> substitute(List<Variable> substituteParameters) {
-                checkArity(substituteParameters);
-                markProcessed();
-                // Use a renewing substitution to remove any non-parameter variables and avoid clashed between variables
-                // coming from different advice in the same clause.
-                var substitution = Substitution.builder().putManyChecked(parameters, substituteParameters).renewing().build();
-                return literals.stream().map(literal -> literal.substitute(substitution)).toList();
-        }
-
-        private void markProcessed() {
-                processed = true;
-        }
-
-        public void checkProcessed() {
-                if (mandatory && !processed) {
-                        throw new IllegalStateException("Mandatory advice %s was not processed".formatted(this));
-                }
-        }
-
-        private void checkArity(List<Variable> toCheck) {
-                if (toCheck.size() != target.arity()) {
-                        throw new IllegalArgumentException("%s needs %d parameters, but got %s".formatted(target.name(),
-                                        target.arity(), parameters.size()));
-                }
-        }
-
-        public static Builder builderFor(AnyPartialSymbol source, PartialRelation target, AdviceSlot slot) {
-                return new Builder(source, target, slot);
-        }
-
-
-        @Override
-        public String toString() {
-                return "Advice[source=%s, target=%s, slot=%s, mandatory=%s, parameters=%s, literals=%s]".formatted(source,
-                                target, slot, mandatory, parameters, literals);
-        }
-
-        public static class Builder {
-                private final AnyPartialSymbol source;
-                private final PartialRelation target;
-                private final AdviceSlot slot;
-                private boolean mandatory;
-                private final List<Variable> parameters = new ArrayList<>();
-                private final List<Literal> literals = new ArrayList<>();
-
-                private Builder(AnyPartialSymbol source, PartialRelation target, AdviceSlot slot) {
-                        this.source = source;
-                        this.target = target;
-                        this.slot = slot;
-                }
-
-                public Builder mandatory(boolean mandatory) {
-                        this.mandatory = mandatory;
-                        return this;
-                }
-
-                public Builder mandatory() {
-                        return mandatory(false);
-                }
-
-                public Builder parameters(List<Variable> variables) {
-                        parameters.addAll(variables);
-                        return this;
-                }
-
-                public Builder parameters(Variable... variables) {
-                        return parameters(List.of(variables));
-                }
-
-                public Builder parameter(Variable variable) {
-                        parameters.add(variable);
-                        return this;
-                }
-
-                public Builder literals(Collection<Literal> literals) {
-                        this.literals.addAll(literals);
-                        return this;
-                }
-
-                public Builder literals(Literal... literals) {
-                        return literals(List.of(literals));
-                }
-
-                public Builder literal(Literal literal) {
-                        literals.add(literal);
-                        return this;
-                }
-
-                public Advice build() {
-                        return new Advice(source, target, slot, mandatory, Collections.unmodifiableList(parameters),
-                                        Collections.unmodifiableList(literals));
-                }
-        }
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/AdviceSlot.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/AdviceSlot.java
deleted file mode 100644
index bab20340..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/AdviceSlot.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.translator;
-
-import tools.refinery.store.representation.TruthValue;
-
-public enum AdviceSlot {
-        EXTEND_MUST(true),
-
-        RESTRICT_MAY(true),
-
-        /**
-         * Same as {@link #RESTRICT_MAY}, but only active if the value of the relation is not {@link TruthValue#TRUE} or
-         * {@link TruthValue#ERROR}.
-         */
-        RESTRICT_NEW(false);
-
-        private final boolean monotonic;
-
-        AdviceSlot(boolean monotonic) {
-                this.monotonic = monotonic;
-        }
-
-        public boolean isMonotonic() {
-                return monotonic;
-        }
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/AnyPartialSymbolTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/AnyPartialSymbolTranslator.java
new file mode 100644
index 00000000..48c84348
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/AnyPartialSymbolTranslator.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator;
+
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.model.ModelStoreConfiguration;
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+
+public sealed interface AnyPartialSymbolTranslator extends ModelStoreConfiguration permits PartialSymbolTranslator {
+        AnyPartialSymbol getPartialSymbol();
+
+        void configure(ModelStoreBuilder storeBuilder);
+}
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
new file mode 100644
index 00000000..c2039afc
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialRelationTranslator.java
@@ -0,0 +1,390 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+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.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;
+import tools.refinery.store.reasoning.interpretation.QueryBasedRelationInterpretationFactory;
+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;
+import tools.refinery.store.reasoning.refinement.StorageRefiner;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+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;
+        private PartialRelationRewriter rewriter;
+        private RelationalQuery query;
+        private RelationalQuery may;
+        private RelationalQuery must;
+        private RelationalQuery candidateMay;
+        private RelationalQuery candidateMust;
+        private RoundingMode roundingMode;
+
+        private PartialRelationTranslator(PartialRelation partialRelation) {
+                super(partialRelation);
+                this.partialRelation = partialRelation;
+        }
+
+        public PartialRelation getPartialRelation() {
+                return partialRelation;
+        }
+
+        @Override
+        public PartialRelationTranslator symbol(AnySymbol storageSymbol) {
+                super.symbol(storageSymbol);
+                return this;
+        }
+
+        @Override
+        public <T> PartialRelationTranslator symbol(Symbol<T> storageSymbol,
+                                                                                                StorageRefiner.Factory<T> storageRefiner) {
+                super.symbol(storageSymbol, storageRefiner);
+                return this;
+        }
+
+        @Override
+        public PartialRelationTranslator interpretation(
+                        PartialInterpretation.Factory<TruthValue, Boolean> interpretationFactory) {
+                super.interpretation(interpretationFactory);
+                return this;
+        }
+
+        @Override
+        public PartialRelationTranslator refiner(
+                        PartialInterpretationRefiner.Factory<TruthValue, Boolean> interpretationRefiner) {
+                super.refiner(interpretationRefiner);
+                return this;
+        }
+
+        public PartialRelationTranslator rewriter(PartialRelationRewriter rewriter) {
+                checkNotConfigured();
+                if (this.rewriter != null) {
+                        throw new IllegalArgumentException("Rewriter was already set");
+                }
+                this.rewriter = rewriter;
+                return this;
+        }
+
+        @Override
+        public PartialRelationTranslator initializer(PartialModelInitializer initializer) {
+                super.initializer(initializer);
+                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) {
+                        throw new IllegalArgumentException("Query was already set");
+                }
+                this.query = query;
+                return this;
+        }
+
+        public PartialRelationTranslator may(RelationalQuery may) {
+                checkNotConfigured();
+                if (this.may != null) {
+                        throw new IllegalArgumentException("May query was already set");
+                }
+                this.may = may;
+                return this;
+        }
+
+        public PartialRelationTranslator mayNever() {
+                var never = createQuery(partialRelation.name() + "#never", (builder, parameters) -> {});
+                may(never);
+                return this;
+        }
+
+        public PartialRelationTranslator must(RelationalQuery must) {
+                checkNotConfigured();
+                if (this.must != null) {
+                        throw new IllegalArgumentException("Must query was already set");
+                }
+                this.must = must;
+                return this;
+        }
+
+        public PartialRelationTranslator candidate(RelationalQuery candidate) {
+                candidateMay(candidate);
+                candidateMust(candidate);
+                return this;
+        }
+
+        public PartialRelationTranslator candidateMay(RelationalQuery candidateMay) {
+                checkNotConfigured();
+                if (this.candidateMay != null) {
+                        throw new IllegalArgumentException("Candidate may query was already set");
+                }
+                this.candidateMay = candidateMay;
+                return this;
+        }
+
+        public PartialRelationTranslator candidateMust(RelationalQuery candidateMust) {
+                checkNotConfigured();
+                if (this.candidateMust != null) {
+                        throw new IllegalArgumentException("Candidate must query was already set");
+                }
+                this.candidateMust = candidateMust;
+                return this;
+        }
+
+        public PartialRelationTranslator roundingMode(RoundingMode roundingMode) {
+                checkNotConfigured();
+                if (this.roundingMode != null) {
+                        throw new IllegalArgumentException("Rounding mode was already set");
+                }
+                this.roundingMode = roundingMode;
+                return this;
+        }
+
+        @Override
+        protected void doConfigure(ModelStoreBuilder storeBuilder) {
+                setFallbackRoundingMode();
+                createFallbackQueryFromRewriter();
+                liftQueries(storeBuilder);
+                createFallbackQueriesFromSymbol();
+                setFallbackCandidateQueries();
+                createFallbackRewriter();
+                createFallbackInterpretation();
+                createFallbackRefiner();
+                createFallbackExclude();
+                createFallbackObjective();
+                super.doConfigure(storeBuilder);
+        }
+
+        private void setFallbackRoundingMode() {
+                if (roundingMode == null) {
+                        roundingMode = query == null && storageSymbol != null ? RoundingMode.PREFER_FALSE : RoundingMode.NONE;
+                }
+        }
+
+        private RelationalQuery createQuery(String name, BiConsumer<QueryBuilder, NodeVariable[]> callback) {
+                int arity = partialRelation.arity();
+                var queryBuilder = Query.builder(name);
+                var parameters = new NodeVariable[arity];
+                for (int i = 0; i < arity; i++) {
+                        parameters[i] = queryBuilder.parameter("p" + 1);
+                }
+                callback.accept(queryBuilder, parameters);
+                return queryBuilder.build();
+        }
+
+        private RelationalQuery createQuery(String name, Constraint constraint) {
+                return createQuery(name, (builder, parameters) -> builder.clause(constraint.call(parameters)));
+        }
+
+        private void createFallbackQueryFromRewriter() {
+                if (rewriter != null && query == null) {
+                        query = createQuery(partialRelation.name(), partialRelation);
+                }
+        }
+
+        private void createFallbackQueriesFromSymbol() {
+                if (storageSymbol == null || storageSymbol.valueType() != TruthValue.class) {
+                        return;
+                }
+                // We checked in the guard clause that this is safe.
+                @SuppressWarnings("unchecked")
+                var typedStorageSymbol = (Symbol<TruthValue>) storageSymbol;
+                var defaultValue = typedStorageSymbol.defaultValue();
+                if (may == null && !defaultValue.may()) {
+                        may = createQuery(DnfLifter.decorateName(partialRelation.name(), Modality.MAY, Concreteness.PARTIAL),
+                                        new MayView(typedStorageSymbol));
+                }
+                if (must == null && !defaultValue.must()) {
+                        must = createQuery(DnfLifter.decorateName(partialRelation.name(), Modality.MUST, Concreteness.PARTIAL),
+                                        new MustView(typedStorageSymbol));
+                }
+        }
+
+        private void liftQueries(ModelStoreBuilder storeBuilder) {
+                if (rewriter instanceof QueryBasedRelationRewriter queryBasedRelationRewriter) {
+                        liftQueriesFromQueryBasedRewriter(queryBasedRelationRewriter);
+                } else if (query != null) {
+                        liftQueriesFromFourValuedQuery(storeBuilder);
+                }
+        }
+
+        private void liftQueriesFromQueryBasedRewriter(QueryBasedRelationRewriter queryBasedRelationRewriter) {
+                if (may == null) {
+                        may = queryBasedRelationRewriter.getMay();
+                }
+                if (must == null) {
+                        must = queryBasedRelationRewriter.getMust();
+                }
+                if (candidateMay == null) {
+                        candidateMay = queryBasedRelationRewriter.getCandidateMay();
+                }
+                if (candidateMust == null) {
+                        candidateMust = queryBasedRelationRewriter.getCandidateMust();
+                }
+        }
+
+        private void liftQueriesFromFourValuedQuery(ModelStoreBuilder storeBuilder) {
+                var reasoningBuilder = storeBuilder.getAdapter(ReasoningBuilder.class);
+                if (may == null) {
+                        may = reasoningBuilder.lift(Modality.MAY, Concreteness.PARTIAL, query);
+                }
+                if (must == null) {
+                        must = reasoningBuilder.lift(Modality.MUST, Concreteness.PARTIAL, query);
+                }
+                if (candidateMay == null) {
+                        candidateMay = reasoningBuilder.lift(Modality.MAY, Concreteness.CANDIDATE, query);
+                }
+                if (candidateMust == null) {
+                        candidateMust = reasoningBuilder.lift(Modality.MAY, Concreteness.CANDIDATE, query);
+                }
+        }
+
+        private void setFallbackCandidateQueries() {
+                if (candidateMay == null) {
+                        candidateMay = switch (roundingMode) {
+                                case NONE, PREFER_TRUE -> may;
+                                case PREFER_FALSE -> must;
+                        };
+                }
+                if (candidateMust == null) {
+                        candidateMust = switch (roundingMode) {
+                                case NONE, PREFER_FALSE -> must;
+                                case PREFER_TRUE -> may;
+                        };
+                }
+        }
+
+        private void createFallbackRewriter() {
+                if (rewriter == null) {
+                        rewriter = new QueryBasedRelationRewriter(may, must, candidateMay, candidateMust);
+                }
+        }
+
+        private void createFallbackInterpretation() {
+                if (interpretationFactory == null) {
+                        interpretationFactory = new QueryBasedRelationInterpretationFactory(may, must, candidateMay, candidateMust);
+                }
+        }
+
+        private void createFallbackRefiner() {
+                if (interpretationRefiner == null && storageSymbol != null && storageSymbol.valueType() == TruthValue.class) {
+                        // We checked in the condition that this is safe.
+                        @SuppressWarnings("unchecked")
+                        var typedStorageSymbol = (Symbol<TruthValue>) storageSymbol;
+                        interpretationRefiner = ConcreteSymbolRefiner.of(typedStorageSymbol);
+                }
+        }
+
+        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;
+        }
+
+        public static PartialRelationTranslator of(PartialRelation relation) {
+                return new PartialRelationTranslator(relation);
+        }
+}
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
new file mode 100644
index 00000000..6cdb287d
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialSymbolTranslator.java
@@ -0,0 +1,212 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+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.refinement.PartialInterpretationRefiner;
+import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
+import tools.refinery.store.reasoning.refinement.StorageRefiner;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.reasoning.seed.SeedInitializer;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.representation.Symbol;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@SuppressWarnings("UnusedReturnValue")
+public abstract sealed class PartialSymbolTranslator<A, C> implements AnyPartialSymbolTranslator
+                permits PartialRelationTranslator {
+        private final PartialSymbol<A, C> partialSymbol;
+        private boolean configured = false;
+        protected PartialInterpretationRefiner.Factory<A, C> interpretationRefiner;
+        protected AnySymbol storageSymbol;
+        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;
+        }
+
+        @Override
+        public PartialSymbol<A, C> getPartialSymbol() {
+                return partialSymbol;
+        }
+
+        @Override
+        public void apply(ModelStoreBuilder storeBuilder) {
+                storeBuilder.getAdapter(ReasoningBuilder.class).partialSymbol(this);
+        }
+
+        public boolean isConfigured() {
+                return configured;
+        }
+
+        protected void checkConfigured() {
+                if (!configured) {
+                        throw new IllegalStateException("Partial symbol was not configured");
+                }
+        }
+
+        protected void checkNotConfigured() {
+                if (configured) {
+                        throw new IllegalStateException("Partial symbol was already configured");
+                }
+        }
+
+        public PartialSymbolTranslator<A, C> symbol(AnySymbol storageSymbol) {
+                return symbol((Symbol<?>) storageSymbol, null);
+        }
+
+        public <T> PartialSymbolTranslator<A, C> symbol(Symbol<T> storageSymbol,
+                                                                                                        StorageRefiner.Factory<T> storageRefiner) {
+                checkNotConfigured();
+                if (this.storageSymbol != null) {
+                        throw new IllegalStateException("Representation symbol was already set");
+                }
+                this.storageSymbol = storageSymbol;
+                this.storageRefiner = storageRefiner;
+                return this;
+        }
+
+        public PartialSymbolTranslator<A, C> interpretation(PartialInterpretation.Factory<A, C> interpretationFactory) {
+                checkNotConfigured();
+                if (this.interpretationFactory != null) {
+                        throw new IllegalStateException("Interpretation factory was already set");
+                }
+                this.interpretationFactory = interpretationFactory;
+                return this;
+        }
+
+        public PartialSymbolTranslator<A, C> refiner(PartialInterpretationRefiner.Factory<A, C> interpretationRefiner) {
+                checkNotConfigured();
+                if (this.interpretationRefiner != null) {
+                        throw new IllegalStateException("Interpretation refiner was already set");
+                }
+                this.interpretationRefiner = interpretationRefiner;
+                return this;
+        }
+
+        public PartialSymbolTranslator<A, C> initializer(PartialModelInitializer initializer) {
+                checkNotConfigured();
+                if (this.initializer != null) {
+                        throw new IllegalStateException("Initializer was already set");
+                }
+                this.initializer = initializer;
+                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();
+                doConfigure(storeBuilder);
+                configured = true;
+        }
+
+        protected void doConfigure(ModelStoreBuilder storeBuilder) {
+                if (interpretationFactory == null) {
+                        throw new IllegalArgumentException("Interpretation factory must be set");
+                }
+                var reasoningBuilder = storeBuilder.getAdapter(ReasoningBuilder.class);
+                if (storageSymbol != null) {
+                        storeBuilder.symbol(storageSymbol);
+                        if (storageRefiner != null) {
+                                registerStorageRefiner(reasoningBuilder, storageRefiner);
+                        }
+                }
+                createFallbackInitializer();
+                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) {
+                // The builder only allows setting a well-typed representation refiner.
+                @SuppressWarnings("unchecked")
+                var typedStorageSymbol = (Symbol<T>) storageSymbol;
+                reasoningBuilder.storageRefiner(typedStorageSymbol, factory);
+        }
+
+        private void createFallbackInitializer() {
+                if (initializer == null &&
+                                storageSymbol != null &&
+                                storageSymbol.valueType().equals(partialSymbol.abstractDomain().abstractType())) {
+                        // The guard clause makes this safe.
+                        @SuppressWarnings("unchecked")
+                        var typedStorageSymbol = (Symbol<A>) storageSymbol;
+                        initializer = new SeedInitializer<>(typedStorageSymbol, partialSymbol);
+                }
+        }
+
+        public PartialInterpretation.Factory<A, C> getInterpretationFactory() {
+                checkConfigured();
+                return interpretationFactory;
+        }
+
+        public PartialInterpretationRefiner.Factory<A, C> getInterpretationRefiner() {
+                checkConfigured();
+                return interpretationRefiner;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/RoundingMode.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/RoundingMode.java
new file mode 100644
index 00000000..dd956a50
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/RoundingMode.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator;
+
+public enum RoundingMode {
+        NONE,
+        PREFER_TRUE,
+        PREFER_FALSE
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslatedRelation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslatedRelation.java
deleted file mode 100644
index 4a5a8843..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslatedRelation.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.translator;
-
-import tools.refinery.store.model.Model;
-import tools.refinery.store.query.term.Variable;
-import tools.refinery.store.query.literal.CallPolarity;
-import tools.refinery.store.query.literal.Literal;
-import tools.refinery.store.reasoning.PartialInterpretation;
-import tools.refinery.store.reasoning.literal.Modality;
-import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.representation.TruthValue;
-
-import java.util.List;
-
-public interface TranslatedRelation {
-        PartialRelation getSource();
-
-        void configure(List<Advice> advices);
-
-        List<Literal> call(CallPolarity polarity, Modality modality, List<Variable> arguments);
-
-        PartialInterpretation<TruthValue, Boolean> createPartialInterpretation(Model model);
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationException.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationException.java
new file mode 100644
index 00000000..edb886ba
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationException.java
@@ -0,0 +1,35 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator;
+
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+
+public class TranslationException extends RuntimeException {
+        private final transient AnyPartialSymbol partialSymbol;
+
+        public TranslationException(AnyPartialSymbol partialSymbol) {
+                this.partialSymbol = partialSymbol;
+        }
+
+        public TranslationException(AnyPartialSymbol partialSymbol, String message) {
+                super(message);
+                this.partialSymbol = partialSymbol;
+        }
+
+        public TranslationException(AnyPartialSymbol partialSymbol, String message, Throwable cause) {
+                super(message, cause);
+                this.partialSymbol = partialSymbol;
+        }
+
+        public TranslationException(AnyPartialSymbol partialSymbol, Throwable cause) {
+                super(cause);
+                this.partialSymbol = partialSymbol;
+        }
+
+        public AnyPartialSymbol getPartialSymbol() {
+                return partialSymbol;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationUnit.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationUnit.java
deleted file mode 100644
index 6e44a7d7..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationUnit.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.translator;
-
-import tools.refinery.store.model.Model;
-import tools.refinery.store.reasoning.ReasoningBuilder;
-
-import java.util.Collection;
-
-public abstract class TranslationUnit {
-        private ReasoningBuilder reasoningBuilder;
-
-        protected ReasoningBuilder getReasoningBuilder() {
-                return reasoningBuilder;
-        }
-
-        public void setPartialInterpretationBuilder(ReasoningBuilder reasoningBuilder) {
-                this.reasoningBuilder = reasoningBuilder;
-                configureReasoningBuilder();
-        }
-
-        protected void configureReasoningBuilder() {
-                // Nothing to configure by default.
-        }
-
-        public abstract Collection<TranslatedRelation> getTranslatedRelations();
-
-        public abstract void initializeModel(Model model, int nodeCount);
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionInterpretation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionInterpretation.java
deleted file mode 100644
index 2a151aa2..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionInterpretation.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.translator.base;
-
-import tools.refinery.store.map.Cursor;
-import tools.refinery.store.model.Interpretation;
-import tools.refinery.store.query.resultset.ResultSet;
-import tools.refinery.store.reasoning.MergeResult;
-import tools.refinery.store.reasoning.PartialInterpretation;
-import tools.refinery.store.reasoning.ReasoningAdapter;
-import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.representation.TruthValue;
-import tools.refinery.store.tuple.Tuple;
-
-public class BaseDecisionInterpretation implements PartialInterpretation<TruthValue, Boolean> {
-        private final ReasoningAdapter reasoningAdapter;
-        private PartialRelation partialRelation;
-        private final ResultSet<Boolean> mustResultSet;
-        private final ResultSet<Boolean> mayResultSet;
-        private final ResultSet<Boolean> errorResultSet;
-        private final ResultSet<Boolean> currentResultSet;
-        private final Interpretation<TruthValue> interpretation;
-
-        public BaseDecisionInterpretation(ReasoningAdapter reasoningAdapter, ResultSet<Boolean> mustResultSet,
-                                                                          ResultSet<Boolean> mayResultSet, ResultSet<Boolean> errorResultSet,
-                                                                          ResultSet<Boolean> currentResultSet, Interpretation<TruthValue> interpretation) {
-                this.reasoningAdapter = reasoningAdapter;
-                this.mustResultSet = mustResultSet;
-                this.mayResultSet = mayResultSet;
-                this.errorResultSet = errorResultSet;
-                this.currentResultSet = currentResultSet;
-                this.interpretation = interpretation;
-        }
-
-        @Override
-        public ReasoningAdapter getAdapter() {
-                return reasoningAdapter;
-        }
-
-        @Override
-        public int countUnfinished() {
-                return 0;
-        }
-
-        @Override
-        public int countErrors() {
-                return errorResultSet.size();
-        }
-
-        @Override
-        public PartialRelation getPartialSymbol() {
-                return partialRelation;
-        }
-
-        @Override
-        public TruthValue get(Tuple key) {
-                return null;
-        }
-
-        @Override
-        public Cursor<Tuple, TruthValue> getAll() {
-                return null;
-        }
-
-        @Override
-        public MergeResult merge(Tuple key, TruthValue value) {
-                TruthValue newValue;
-                switch (value) {
-                case UNKNOWN -> {
-                        return MergeResult.UNCHANGED;
-                }
-                case TRUE -> newValue = mayResultSet.get(key) ? TruthValue.TRUE : TruthValue.ERROR;
-                case FALSE -> newValue = mustResultSet.get(key) ? TruthValue.ERROR : TruthValue.FALSE;
-                case ERROR -> newValue = TruthValue.ERROR;
-                default -> throw new IllegalArgumentException("Unknown truth value: " + value);
-                }
-                var oldValue = interpretation.put(key, newValue);
-                return oldValue == TruthValue.ERROR ? MergeResult.UNCHANGED : MergeResult.REFINED;
-        }
-
-        @Override
-        public Boolean getConcrete(Tuple key) {
-                return currentResultSet.get(key);
-        }
-
-        @Override
-        public Cursor<Tuple, Boolean> getAllConcrete() {
-                return null;
-        }
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionTranslationUnit.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionTranslationUnit.java
deleted file mode 100644
index a1e4b816..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionTranslationUnit.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.translator.base;
-
-import tools.refinery.store.model.Model;
-import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.reasoning.seed.Seed;
-import tools.refinery.store.reasoning.seed.UniformSeed;
-import tools.refinery.store.reasoning.translator.TranslatedRelation;
-import tools.refinery.store.reasoning.translator.TranslationUnit;
-import tools.refinery.store.representation.Symbol;
-import tools.refinery.store.representation.TruthValue;
-
-import java.util.Collection;
-import java.util.List;
-
-public class BaseDecisionTranslationUnit extends TranslationUnit {
-        private final PartialRelation partialRelation;
-        private final Seed<TruthValue> seed;
-        private final Symbol<TruthValue> symbol;
-
-        public BaseDecisionTranslationUnit(PartialRelation partialRelation, Seed<TruthValue> seed) {
-                if (seed.arity() != partialRelation.arity()) {
-                        throw new IllegalArgumentException("Expected seed with arity %d for %s, got arity %s"
-                                        .formatted(partialRelation.arity(), partialRelation, seed.arity()));
-                }
-                this.partialRelation = partialRelation;
-                this.seed = seed;
-                symbol = Symbol.of(partialRelation.name(), partialRelation.arity(), TruthValue.class, TruthValue.UNKNOWN);
-        }
-
-        public BaseDecisionTranslationUnit(PartialRelation partialRelation) {
-                this(partialRelation, new UniformSeed<>(partialRelation.arity(), TruthValue.UNKNOWN));
-        }
-
-        @Override
-        public Collection<TranslatedRelation> getTranslatedRelations() {
-                return List.of(new TranslatedBaseDecision(getReasoningBuilder(), partialRelation, symbol));
-        }
-
-        @Override
-        public void initializeModel(Model model, int nodeCount) {
-                var interpretation = model.getInterpretation(symbol);
-                interpretation.putAll(seed.getCursor(TruthValue.UNKNOWN, nodeCount));
-        }
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/TranslatedBaseDecision.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/TranslatedBaseDecision.java
deleted file mode 100644
index 4782eb46..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/TranslatedBaseDecision.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.translator.base;
-
-import tools.refinery.store.model.Model;
-import tools.refinery.store.query.term.Variable;
-import tools.refinery.store.query.literal.CallPolarity;
-import tools.refinery.store.query.literal.Literal;
-import tools.refinery.store.reasoning.PartialInterpretation;
-import tools.refinery.store.reasoning.ReasoningBuilder;
-import tools.refinery.store.reasoning.literal.Modality;
-import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.reasoning.translator.Advice;
-import tools.refinery.store.reasoning.translator.TranslatedRelation;
-import tools.refinery.store.representation.Symbol;
-import tools.refinery.store.representation.TruthValue;
-
-import java.util.List;
-
-class TranslatedBaseDecision implements TranslatedRelation {
-        private final ReasoningBuilder reasoningBuilder;
-        private final PartialRelation partialRelation;
-        private final Symbol<TruthValue> symbol;
-
-        public TranslatedBaseDecision(ReasoningBuilder reasoningBuilder, PartialRelation partialRelation,
-                                                                  Symbol<TruthValue> symbol) {
-                this.reasoningBuilder = reasoningBuilder;
-                this.partialRelation = partialRelation;
-                this.symbol = symbol;
-        }
-
-        @Override
-        public PartialRelation getSource() {
-                return partialRelation;
-        }
-
-        @Override
-        public void configure(List<Advice> advices) {
-
-        }
-
-        @Override
-        public List<Literal> call(CallPolarity polarity, Modality modality, List<Variable> arguments) {
-                return null;
-        }
-
-        @Override
-        public PartialInterpretation<TruthValue, Boolean> createPartialInterpretation(Model model) {
-                return null;
-        }
-}
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
new file mode 100644
index 00000000..61037be3
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java
@@ -0,0 +1,255 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+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;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.literal.Connectivity;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.literal.RepresentativeElectionLiteral;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.view.AnySymbolView;
+import tools.refinery.store.reasoning.lifting.DnfLifter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.literal.CountLowerBoundLiteral;
+import tools.refinery.store.reasoning.literal.Modality;
+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;
+import tools.refinery.store.representation.cardinality.CardinalityIntervals;
+import tools.refinery.store.representation.cardinality.FiniteUpperCardinality;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import static tools.refinery.store.query.literal.Literals.check;
+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.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);
+        public static final PartialRelation INVALID_CONTAINER = new PartialRelation("invalidContainer",
+                        1);
+        public static final PartialRelation CONTAINS_SYMBOL = new PartialRelation("contains", 2);
+
+        private final Symbol<InferredContainment> containsStorage = Symbol.of("CONTAINS", 2, InferredContainment.class,
+                        InferredContainment.UNKNOWN);
+        private final AnySymbolView forbiddenContainsView = new ForbiddenContainsView(containsStorage);
+        private final RelationalQuery containsMayNewTargetHelper;
+        private final RelationalQuery containsMayExistingHelper;
+        private final RelationalQuery weakComponents;
+        private final RelationalQuery strongComponents;
+        private final Map<PartialRelation, ContainmentInfo> containmentInfoMap;
+
+        public ContainmentHierarchyTranslator(Map<PartialRelation, ContainmentInfo> containmentInfoMap) {
+                this.containmentInfoMap = containmentInfoMap;
+
+                var name = CONTAINS_SYMBOL.name();
+
+                containsMayNewTargetHelper = Query.of(name + "#mayNewTargetHelper", (builder, child) -> builder
+                                .clause(Integer.class, existingContainers -> List.of(
+                                                may(CONTAINED_SYMBOL.call(child)),
+                                                new CountLowerBoundLiteral(existingContainers, CONTAINS_SYMBOL, List.of(Variable.of(), child)),
+                                                check(less(existingContainers, constant(1)))
+                                )));
+
+                containsMayExistingHelper = Query.of(name + "#mayExistingHelper", (builder, parent, child) -> builder
+                                .clause(Integer.class, existingContainers -> List.of(
+                                                must(CONTAINS_SYMBOL.call(parent, child)),
+                                                not(forbiddenContainsView.call(parent, child))
+                                                // Violation of monotonicity:
+                                                // Containment edges violating upper multiplicity will not be marked as {@code ERROR}, but the
+                                                // {@code invalidNumberOfContainers} error pattern will already mark the node as invalid.
+                                )));
+
+                var mustExistBothContains = Query.of(name + "#mustExistBoth", (builder, parent, child) -> builder.clause(
+                                must(CONTAINS_SYMBOL.call(parent, child)),
+                                must(EXISTS_SYMBOL.call(parent)),
+                                must(EXISTS_SYMBOL.call(child))
+                ));
+
+                weakComponents = Query.of(name + "#weakComponents", (builder, node, representative) -> builder.clause(
+                                new RepresentativeElectionLiteral(Connectivity.WEAK, mustExistBothContains.getDnf(), node,
+                                                representative)
+                ));
+
+                strongComponents = Query.of(name + "#strongComponents", (builder, node, representative) -> builder.clause(
+                                new RepresentativeElectionLiteral(Connectivity.STRONG, mustExistBothContains.getDnf(), node,
+                                                representative)
+                ));
+        }
+
+        @Override
+        public void apply(ModelStoreBuilder storeBuilder) {
+                storeBuilder.symbol(containsStorage);
+                translateContains(storeBuilder);
+                translateInvalidContainer(storeBuilder);
+                for (var entry : containmentInfoMap.entrySet()) {
+                        var linkType = entry.getKey();
+                        var info = entry.getValue();
+                        translateContainmentLinkType(storeBuilder, linkType, info);
+                        translateInvalidMultiplicity(storeBuilder, linkType, info);
+                }
+                translateFocusNotContained(storeBuilder);
+        }
+
+        private void translateContainmentLinkType(ModelStoreBuilder storeBuilder, PartialRelation linkType,
+                                                                                          ContainmentInfo info) {
+                var name = linkType.name();
+                var sourceType = info.sourceType();
+                var targetType = info.targetType();
+                var upperCardinality = info.multiplicity().multiplicity().upperBound();
+
+                var mayNewSourceHelper = Query.of(name + "#mayNewSourceHelper", (builder, parent) -> {
+                        var literals = new ArrayList<Literal>();
+                        literals.add(may(sourceType.call(parent)));
+                        if (upperCardinality instanceof FiniteUpperCardinality finiteUpperCardinality) {
+                                var existingCount = Variable.of("existingCount", Integer.class);
+                                literals.add(new CountLowerBoundLiteral(existingCount, linkType, List.of(parent, Variable.of())));
+                                literals.add(check(less(existingCount, constant(finiteUpperCardinality.finiteUpperBound()))));
+                        }
+                        builder.clause(literals);
+                });
+
+                var mayNewTargetHelper = Query.of(name + "#mayNewTargetHelper", (builder, child) -> builder.clause(
+                                containsMayNewTargetHelper.call(child),
+                                may(targetType.call(child))
+                ));
+
+                var forbiddenLinkView = new ForbiddenContainmentLinkView(containsStorage, linkType);
+
+                var mayNewHelper = Query.of(name + "#mayNewHelper", (builder, parent, child) -> builder.clause(
+                                mayNewSourceHelper.call(parent),
+                                mayNewTargetHelper.call(child),
+                                not(must(CONTAINS_SYMBOL.call(parent, child))),
+                                not(forbiddenLinkView.call(parent, child))
+                ));
+
+                var mayExistingHelper = Query.of(name + "#mayExistingHelper", (builder, parent, child) -> builder.clause(
+                                must(linkType.call(parent, child)),
+                                containsMayExistingHelper.call(parent, child),
+                                may(sourceType.call(parent)),
+                                may(targetType.call(child)),
+                                not(forbiddenLinkView.call(parent, child))
+                                // Violation of monotonicity:
+                                // Containment edges violating upper multiplicity will not be marked as {@code ERROR}, but the
+                                // {@code invalidNumberOfContainers} error pattern will already mark the node as invalid.
+                ));
+
+                var may = Query.of(name + "#may", (builder, parent, child) -> builder
+                                .clause(
+                                                mayNewHelper.call(parent, child),
+                                                not(weakComponents.call(parent, Variable.of()))
+                                )
+                                .clause(representative -> List.of(
+                                                mayNewHelper.call(parent, child),
+                                                weakComponents.call(parent, representative),
+                                                // Violation of para-consistency:
+                                                // If there is a surely existing node with at least two containers, its (transitive) containers
+                                                // will end up in the same weakly connected component, and we will spuriously mark the
+                                                // containment edge between the (transitive) containers as {@code FALSE}. However, such
+                                                // models can never be finished.
+                                                //
+                                                // Violation of monotonicity:
+                                                // if the a {@code TRUE} value is added to the representation in the previous situation,
+                                                // we'll check strongly connected components instead of weakly connected ones. Therefore, the
+                                                // view for the partial symbol will change from {@code FALSE} to {@code TRUE}. This doesn't
+                                                // affect the overall inconsistency of the partial model (due to the surely existing node
+                                                // with multiple containers).
+                                                not(weakComponents.call(child, representative))
+                                ))
+                                .clause(
+                                                mayExistingHelper.call(parent, child),
+                                                not(strongComponents.call(parent, Variable.of()))
+                                )
+                                .clause(representative -> List.of(
+                                                mayExistingHelper.call(parent, child),
+                                                strongComponents.call(parent, representative),
+                                                not(strongComponents.call(child, representative))
+                                )));
+
+                storeBuilder.with(PartialRelationTranslator.of(linkType)
+                                .may(may)
+                                .must(Query.of(name + "#must", (builder, parent, child) -> builder.clause(
+                                                new MustContainmentLinkView(containsStorage, linkType).call(parent, child)
+                                )))
+                                .roundingMode(RoundingMode.PREFER_FALSE)
+                                .refiner(ContainmentLinkRefiner.of(linkType, containsStorage, info.sourceType(), info.targetType()))
+                                .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,
+                                                                                          ContainmentInfo info) {
+                storeBuilder.with(new InvalidMultiplicityErrorTranslator(info.sourceType(), linkType, false,
+                                info.multiplicity()));
+        }
+
+        private void translateContains(ModelStoreBuilder storeBuilder) {
+                var name = CONTAINS_SYMBOL.name();
+                var mustName = DnfLifter.decorateName(name, Modality.MUST, Concreteness.PARTIAL);
+
+                storeBuilder.with(PartialRelationTranslator.of(CONTAINS_SYMBOL)
+                                .query(Query.of(name, (builder, parent, child) -> {
+                                        for (var linkType : containmentInfoMap.keySet()) {
+                                                builder.clause(linkType.call(parent, child));
+                                        }
+                                }))
+                                .must(Query.of(mustName, (builder, parent, child) -> builder.clause(
+                                                new MustContainsView(containsStorage).call(parent, child)
+                                ))));
+        }
+
+        private void translateInvalidContainer(ModelStoreBuilder storeBuilder) {
+                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/containment/ContainmentInfo.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentInfo.java
new file mode 100644
index 00000000..e3457fa7
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentInfo.java
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.containment;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
+import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
+
+public record ContainmentInfo(PartialRelation sourceType, Multiplicity multiplicity,
+                                                          PartialRelation targetType) {
+        public ContainmentInfo {
+                if (sourceType.arity() != 1) {
+                        throw new TranslationException(sourceType, "Expected source type %s to be of arity 1, got %d instead"
+                                                        .formatted(sourceType, sourceType.arity()));
+                }
+                if (targetType.arity() != 1) {
+                        throw new TranslationException(targetType, "Expected target type %s to be of arity 1, got %d instead"
+                                        .formatted(targetType, targetType.arity()));
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentLinkRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentLinkRefiner.java
new file mode 100644
index 00000000..497ed98f
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentLinkRefiner.java
@@ -0,0 +1,128 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.containment;
+
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.refinement.AbstractPartialInterpretationRefiner;
+import tools.refinery.store.reasoning.refinement.PartialInterpretationRefiner;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.ArrayList;
+import java.util.Set;
+
+class ContainmentLinkRefiner extends AbstractPartialInterpretationRefiner<TruthValue, Boolean> {
+        private final Factory factory;
+        private final Interpretation<InferredContainment> interpretation;
+        private final PartialInterpretationRefiner<TruthValue, Boolean> sourceRefiner;
+        private final PartialInterpretationRefiner<TruthValue, Boolean> targetRefiner;
+
+        public ContainmentLinkRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
+                                                                  Factory factory) {
+                super(adapter, partialSymbol);
+                this.factory = factory;
+                interpretation = adapter.getModel().getInterpretation(factory.symbol);
+                sourceRefiner = adapter.getRefiner(factory.sourceType);
+                targetRefiner = adapter.getRefiner(factory.targetType);
+        }
+
+        @Override
+        public boolean merge(Tuple key, TruthValue value) {
+                var oldValue = interpretation.get(key);
+                var newValue = mergeLink(oldValue, value);
+                if (oldValue != newValue) {
+                        interpretation.put(key, newValue);
+                }
+                if (value.must()) {
+                        return sourceRefiner.merge(Tuple.of(key.get(0)), TruthValue.TRUE) &&
+                                        targetRefiner.merge(Tuple.of(key.get(1)), TruthValue.TRUE);
+                }
+                return true;
+        }
+
+        public InferredContainment mergeLink(InferredContainment oldValue, TruthValue toMerge) {
+                return switch (toMerge) {
+                        case UNKNOWN -> oldValue;
+                        case TRUE -> mustLink(oldValue);
+                        case FALSE -> forbidLink(oldValue);
+                        case ERROR -> errorLink(oldValue);
+                };
+        }
+
+        public InferredContainment mustLink(InferredContainment oldValue) {
+                var mustLinks = oldValue.mustLinks();
+                if (oldValue.contains().may() && mustLinks.isEmpty() && oldValue.forbiddenLinks().isEmpty()) {
+                        return factory.trueLink;
+                }
+                if (mustLinks.contains(factory.linkType)) {
+                        return oldValue;
+                }
+                return new InferredContainment(oldValue.contains().merge(TruthValue.TRUE),
+                                addToSet(mustLinks, factory.linkType), oldValue.forbiddenLinks());
+        }
+
+        public InferredContainment forbidLink(InferredContainment oldValue) {
+                var forbiddenLinks = oldValue.forbiddenLinks();
+                if (oldValue.contains() == TruthValue.UNKNOWN && oldValue.mustLinks().isEmpty() && forbiddenLinks.isEmpty()) {
+                        return factory.falseLinkUnknownContains;
+                }
+                if (forbiddenLinks.contains(factory.linkType)) {
+                        return oldValue;
+                }
+                return new InferredContainment(oldValue.contains(), oldValue.mustLinks(),
+                                addToSet(forbiddenLinks, factory.linkType));
+        }
+
+        public InferredContainment errorLink(InferredContainment oldValue) {
+                return new InferredContainment(TruthValue.ERROR, addToSet(oldValue.mustLinks(), factory.linkType),
+                                addToSet(oldValue.forbiddenLinks(), factory.linkType));
+        }
+
+        private static Set<PartialRelation> addToSet(Set<PartialRelation> oldSet, PartialRelation linkType) {
+                if (oldSet.isEmpty()) {
+                        return Set.of(linkType);
+                }
+                var newElements = new ArrayList<PartialRelation>(oldSet.size() + 1);
+                newElements.addAll(oldSet);
+                newElements.add(linkType);
+                return Set.copyOf(newElements);
+        }
+
+        public static PartialInterpretationRefiner.Factory<TruthValue, Boolean> of(
+                        PartialRelation linkType, Symbol<InferredContainment> symbol, PartialRelation sourceType,
+                        PartialRelation targetType) {
+                return new Factory(linkType, symbol, sourceType, targetType);
+        }
+
+        private static class Factory implements PartialInterpretationRefiner.Factory<TruthValue, Boolean> {
+                public final PartialRelation linkType;
+                public final Symbol<InferredContainment> symbol;
+                public final PartialRelation targetType;
+                public final PartialRelation sourceType;
+                public final InferredContainment trueLink;
+                public final InferredContainment falseLinkUnknownContains;
+
+                public Factory(PartialRelation linkType, Symbol<InferredContainment> symbol, PartialRelation sourceType,
+                                           PartialRelation targetType) {
+                        this.linkType = linkType;
+                        this.symbol = symbol;
+                        this.sourceType = sourceType;
+                        this.targetType = targetType;
+                        trueLink = new InferredContainment(TruthValue.TRUE, Set.of(linkType), Set.of());
+                        falseLinkUnknownContains = new InferredContainment(TruthValue.FALSE, Set.of(), Set.of(linkType));
+                }
+
+                @Override
+                public PartialInterpretationRefiner<TruthValue, Boolean> create(
+                                ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol) {
+                        return new ContainmentLinkRefiner(adapter, partialSymbol, this);
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ForbiddenContainmentLinkView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ForbiddenContainmentLinkView.java
new file mode 100644
index 00000000..cf0e2971
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ForbiddenContainmentLinkView.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.containment;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+class ForbiddenContainmentLinkView extends InferredContainmentLinkView {
+        public ForbiddenContainmentLinkView(Symbol<InferredContainment> symbol, PartialRelation link) {
+                super(symbol, "must", link);
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, InferredContainment value) {
+                return value.forbiddenLinks().contains(link);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ForbiddenContainsView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ForbiddenContainsView.java
new file mode 100644
index 00000000..efe674f1
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ForbiddenContainsView.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.containment;
+
+import tools.refinery.store.query.view.TuplePreservingView;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+class ForbiddenContainsView extends TuplePreservingView<InferredContainment> {
+        public ForbiddenContainsView(Symbol<InferredContainment> symbol) {
+                super(symbol, "contains#forbidden");
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, InferredContainment value) {
+                return !value.contains().may();
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainment.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainment.java
new file mode 100644
index 00000000..8df23d9a
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainment.java
@@ -0,0 +1,77 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.containment;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.TruthValue;
+
+import java.util.Objects;
+import java.util.Set;
+
+final class InferredContainment {
+        public static final InferredContainment UNKNOWN = new InferredContainment(
+                        TruthValue.UNKNOWN, Set.of(), Set.of());
+        private final TruthValue contains;
+        private final Set<PartialRelation> mustLinks;
+        private final Set<PartialRelation> forbiddenLinks;
+        private final int hashCode;
+
+        public InferredContainment(TruthValue contains, Set<PartialRelation> mustLinks,
+                                                           Set<PartialRelation> forbiddenLinks) {
+                this.contains = adjustContains(contains, mustLinks, forbiddenLinks);
+                this.mustLinks = mustLinks;
+                this.forbiddenLinks = forbiddenLinks;
+                hashCode = Objects.hash(contains, mustLinks, forbiddenLinks);
+        }
+
+        private static TruthValue adjustContains(TruthValue contains, Set<PartialRelation> mustLinks,
+                                                                                         Set<PartialRelation> forbiddenLinks) {
+                var result = contains;
+                if (!mustLinks.isEmpty()) {
+                        result = result.merge(TruthValue.TRUE);
+                }
+                boolean hasErrorLink = mustLinks.stream().anyMatch(forbiddenLinks::contains);
+                if (mustLinks.size() >= 2 || hasErrorLink) {
+                        result = result.merge(TruthValue.ERROR);
+                }
+                return result;
+        }
+
+        public TruthValue contains() {
+                return contains;
+        }
+
+        public Set<PartialRelation> mustLinks() {
+                return mustLinks;
+        }
+
+        public Set<PartialRelation> forbiddenLinks() {
+                return forbiddenLinks;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (obj == this) return true;
+                if (obj == null || obj.getClass() != this.getClass()) return false;
+                var that = (InferredContainment) obj;
+                return Objects.equals(this.contains, that.contains) &&
+                                Objects.equals(this.mustLinks, that.mustLinks) &&
+                                Objects.equals(this.forbiddenLinks, that.forbiddenLinks);
+        }
+
+        @Override
+        public int hashCode() {
+                return hashCode;
+        }
+
+        @Override
+        public String toString() {
+                return "InferredContainment[" +
+                                "contains=" + contains + ", " +
+                                "mustLinks=" + mustLinks + ", " +
+                                "forbiddenLinks=" + forbiddenLinks + ']';
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainmentLinkView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainmentLinkView.java
new file mode 100644
index 00000000..d187ad91
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/InferredContainmentLinkView.java
@@ -0,0 +1,35 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.containment;
+
+import tools.refinery.store.query.view.TuplePreservingView;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.Symbol;
+
+import java.util.Objects;
+
+abstract class InferredContainmentLinkView extends TuplePreservingView<InferredContainment> {
+        protected final PartialRelation link;
+
+        protected InferredContainmentLinkView(Symbol<InferredContainment> symbol, String name, PartialRelation link) {
+                super(symbol, link.name() + "#" + name);
+                this.link = link;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                if (!super.equals(o)) return false;
+                InferredContainmentLinkView that = (InferredContainmentLinkView) o;
+                return Objects.equals(link, that.link);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), link);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/MustContainmentLinkView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/MustContainmentLinkView.java
new file mode 100644
index 00000000..474942d6
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/MustContainmentLinkView.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.containment;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+class MustContainmentLinkView extends InferredContainmentLinkView {
+        public MustContainmentLinkView(Symbol<InferredContainment> symbol, PartialRelation link) {
+                super(symbol, "must", link);
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, InferredContainment value) {
+                return value.mustLinks().contains(link);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/MustContainsView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/MustContainsView.java
new file mode 100644
index 00000000..6bc62a59
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/MustContainsView.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.containment;
+
+import tools.refinery.store.query.view.TuplePreservingView;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+class MustContainsView extends TuplePreservingView<InferredContainment> {
+        public MustContainsView(Symbol<InferredContainment> symbol) {
+                super(symbol, "contains#must");
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, InferredContainment value) {
+                return value.contains().must();
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/CrossReferenceUtils.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/CrossReferenceUtils.java
new file mode 100644
index 00000000..c4a2f2b3
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/CrossReferenceUtils.java
@@ -0,0 +1,57 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.crossreference;
+
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.reasoning.literal.CountLowerBoundLiteral;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
+import tools.refinery.store.representation.cardinality.FiniteUpperCardinality;
+
+import java.util.ArrayList;
+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.less;
+import static tools.refinery.store.reasoning.literal.PartialLiterals.may;
+
+class CrossReferenceUtils {
+        private CrossReferenceUtils() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static RelationalQuery createMayHelper(PartialRelation linkType, PartialRelation type,
+                                                                                                  Multiplicity multiplicity, boolean inverse) {
+                String name;
+                NodeVariable variable;
+                List<Variable> arguments;
+                if (inverse) {
+                        name = "Target";
+                        variable = Variable.of("target");
+                        arguments = List.of(Variable.of("source"), variable);
+                } else {
+                        name = "Source";
+                        variable = Variable.of("source");
+                        arguments = List.of(variable, Variable.of("target"));
+                }
+                var builder = Query.builder(linkType.name() + "#mayNew" + name);
+                builder.parameter(variable);
+                var literals = new ArrayList<Literal>();
+                literals.add(may(type.call(variable)));
+                if (multiplicity.multiplicity().upperBound() instanceof FiniteUpperCardinality finiteUpperCardinality) {
+                        var existingLinks = Variable.of("existingLinks", Integer.class);
+                        literals.add(new CountLowerBoundLiteral(existingLinks, linkType, arguments));
+                        literals.add(check(less(existingLinks, constant(finiteUpperCardinality.finiteUpperBound()))));
+                }
+                builder.clause(literals);
+                return builder.build();
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceInfo.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceInfo.java
new file mode 100644
index 00000000..d8c6a5ea
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceInfo.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.crossreference;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
+
+public record DirectedCrossReferenceInfo(PartialRelation sourceType, Multiplicity sourceMultiplicity,
+                                                                                 PartialRelation targetType, Multiplicity targetMultiplicity) {
+        public boolean isConstrained() {
+                return sourceMultiplicity.isConstrained() || targetMultiplicity.isConstrained();
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceRefiner.java
new file mode 100644
index 00000000..0700f9f7
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceRefiner.java
@@ -0,0 +1,46 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.crossreference;
+
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.refinement.ConcreteSymbolRefiner;
+import tools.refinery.store.reasoning.refinement.PartialInterpretationRefiner;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+class DirectedCrossReferenceRefiner extends ConcreteSymbolRefiner<TruthValue, Boolean> {
+        private final PartialInterpretationRefiner<TruthValue, Boolean> sourceRefiner;
+        private final PartialInterpretationRefiner<TruthValue, Boolean> targetRefiner;
+
+        public DirectedCrossReferenceRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
+                                                                                 Symbol<TruthValue> concreteSymbol, PartialRelation sourceType,
+                                                                                 PartialRelation targetType) {
+                super(adapter, partialSymbol, concreteSymbol);
+                sourceRefiner = adapter.getRefiner(sourceType);
+                targetRefiner = adapter.getRefiner(targetType);
+        }
+
+        @Override
+        public boolean merge(Tuple key, TruthValue value) {
+                if (!super.merge(key, value)) {
+                        return false;
+                }
+                if (value.must()) {
+                        return sourceRefiner.merge(Tuple.of(key.get(0)), TruthValue.TRUE) &&
+                                        targetRefiner.merge(Tuple.of(key.get(1)), TruthValue.TRUE);
+                }
+                return true;
+        }
+
+        public static Factory<TruthValue, Boolean> of(Symbol<TruthValue> concreteSymbol, PartialRelation sourceType,
+                                                                                                  PartialRelation targetType) {
+                return (adapter, partialSymbol) -> new DirectedCrossReferenceRefiner(adapter, partialSymbol, concreteSymbol,
+                                sourceType, targetType);
+        }
+}
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
new file mode 100644
index 00000000..9028337c
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/DirectedCrossReferenceTranslator.java
@@ -0,0 +1,94 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+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;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.view.ForbiddenView;
+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.refinement.RefinementBasedInitializer;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.reasoning.translator.multiplicity.InvalidMultiplicityErrorTranslator;
+import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
+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.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;
+        private final DirectedCrossReferenceInfo info;
+        private final Symbol<TruthValue> symbol;
+
+        public DirectedCrossReferenceTranslator(PartialRelation linkType, DirectedCrossReferenceInfo info) {
+                this.linkType = linkType;
+                this.info = info;
+                symbol = Symbol.of(linkType.name(), 2, TruthValue.class, TruthValue.UNKNOWN);
+        }
+
+        @Override
+        public void apply(ModelStoreBuilder storeBuilder) {
+                var name = linkType.name();
+                var sourceType = info.sourceType();
+                var targetType = info.targetType();
+                var mayNewSource = createMayHelper(sourceType, info.sourceMultiplicity(), false);
+                var mayNewTarget = createMayHelper(targetType, info.targetMultiplicity(), true);
+                var forbiddenView = new ForbiddenView(symbol);
+                var mayName = DnfLifter.decorateName(name, Modality.MAY, Concreteness.PARTIAL);
+
+                storeBuilder.with(PartialRelationTranslator.of(linkType)
+                                .symbol(symbol)
+                                .may(Query.of(mayName, (builder, source, target) -> {
+                                        builder.clause(
+                                                        mayNewSource.call(source),
+                                                        mayNewTarget.call(target),
+                                                        not(forbiddenView.call(source, target))
+                                        );
+                                        if (info.isConstrained()) {
+                                                // Violation of monotonicity:
+                                                // Edges violating upper multiplicity will not be marked as {@code ERROR}, but the
+                                                // corresponding error pattern will already mark the node as invalid.
+                                                builder.clause(
+                                                                must(linkType.call(source, target)),
+                                                                not(forbiddenView.call(source, target)),
+                                                                may(sourceType.call(source)),
+                                                                may(targetType.call(target))
+                                                );
+                                        }
+                                }))
+                                .refiner(DirectedCrossReferenceRefiner.of(symbol, sourceType, targetType))
+                                .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()));
+
+                storeBuilder.with(new InvalidMultiplicityErrorTranslator(targetType, linkType, true,
+                                info.targetMultiplicity()));
+        }
+
+        private RelationalQuery createMayHelper(PartialRelation type, Multiplicity multiplicity, boolean inverse) {
+                return CrossReferenceUtils.createMayHelper(linkType, type, multiplicity, inverse);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInfo.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInfo.java
new file mode 100644
index 00000000..fe99bc54
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInfo.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.crossreference;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
+
+public record UndirectedCrossReferenceInfo(PartialRelation type, Multiplicity multiplicity) {
+        public boolean isConstrained() {
+                return multiplicity.isConstrained();
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceRefiner.java
new file mode 100644
index 00000000..43c1462b
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceRefiner.java
@@ -0,0 +1,44 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.crossreference;
+
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.refinement.ConcreteSymbolRefiner;
+import tools.refinery.store.reasoning.refinement.PartialInterpretationRefiner;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+class UndirectedCrossReferenceRefiner extends ConcreteSymbolRefiner<TruthValue, Boolean> {
+        private final PartialInterpretationRefiner<TruthValue, Boolean> sourceRefiner;
+
+        public UndirectedCrossReferenceRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
+                                                                                   Symbol<TruthValue> concreteSymbol, PartialRelation sourceType) {
+                super(adapter, partialSymbol, concreteSymbol);
+                sourceRefiner = adapter.getRefiner(sourceType);
+        }
+
+        @Override
+        public boolean merge(Tuple key, TruthValue value) {
+                int source = key.get(0);
+                int target = key.get(1);
+                if (!super.merge(key, value) || !super.merge(Tuple.of(target, source), value)) {
+                        return false;
+                }
+                if (value.must()) {
+                        return sourceRefiner.merge(Tuple.of(source), TruthValue.TRUE) &&
+                                        sourceRefiner.merge(Tuple.of(target), TruthValue.TRUE);
+                }
+                return true;
+        }
+
+        public static Factory<TruthValue, Boolean> of(Symbol<TruthValue> concreteSymbol, PartialRelation sourceType) {
+                return (adapter, partialSymbol) -> new UndirectedCrossReferenceRefiner(adapter, partialSymbol, concreteSymbol,
+                                sourceType);
+        }
+}
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
new file mode 100644
index 00000000..c554e2a4
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceTranslator.java
@@ -0,0 +1,83 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+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;
+import tools.refinery.store.query.view.ForbiddenView;
+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.refinement.RefinementBasedInitializer;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.reasoning.translator.multiplicity.InvalidMultiplicityErrorTranslator;
+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.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;
+        private final UndirectedCrossReferenceInfo info;
+        private final Symbol<TruthValue> symbol;
+
+        public UndirectedCrossReferenceTranslator(PartialRelation linkType, UndirectedCrossReferenceInfo info) {
+                this.linkType = linkType;
+                this.info = info;
+                symbol = Symbol.of(linkType.name(), 2, TruthValue.class, TruthValue.UNKNOWN);
+        }
+
+        @Override
+        public void apply(ModelStoreBuilder storeBuilder) {
+                var name = linkType.name();
+                var type = info.type();
+                var forbiddenView = new ForbiddenView(symbol);
+                var mayName = DnfLifter.decorateName(name, Modality.MAY, Concreteness.PARTIAL);
+
+                var mayNewSource = CrossReferenceUtils.createMayHelper(linkType, type, info.multiplicity(), false);
+
+                storeBuilder.with(PartialRelationTranslator.of(linkType)
+                                .symbol(symbol)
+                                .may(Query.of(mayName, (builder, source, target) -> {
+                                        builder.clause(
+                                                        mayNewSource.call(source),
+                                                        mayNewSource.call(target),
+                                                        not(forbiddenView.call(source, target))
+                                        );
+                                        if (info.isConstrained()) {
+                                                // Violation of monotonicity:
+                                                // Edges violating upper multiplicity will not be marked as {@code ERROR}, but the
+                                                // corresponding error pattern will already mark the node as invalid.
+                                                builder.clause(
+                                                                must(linkType.call(source, target)),
+                                                                not(forbiddenView.call(source, target)),
+                                                                may(type.call(source)),
+                                                                may(type.call(target))
+                                                );
+                                        }
+                                }))
+                                .refiner(UndirectedCrossReferenceRefiner.of(symbol, type))
+                                .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/metamodel/ContainedTypeHierarchyBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ContainedTypeHierarchyBuilder.java
new file mode 100644
index 00000000..a21da3d4
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ContainedTypeHierarchyBuilder.java
@@ -0,0 +1,33 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.metamodel;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
+import tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator;
+import tools.refinery.store.reasoning.translator.typehierarchy.TypeHierarchyBuilder;
+
+import java.util.Collection;
+
+public class ContainedTypeHierarchyBuilder extends TypeHierarchyBuilder {
+        ContainedTypeHierarchyBuilder() {
+        }
+
+        boolean isInvalidType(PartialRelation type) {
+                return !typeInfoMap.containsKey(type);
+        }
+
+        void setContainedTypes(Collection<PartialRelation> containedTypes) {
+                for (var containedType : containedTypes) {
+                        var currentInfo = typeInfoMap.get(containedType);
+                        if (currentInfo == null) {
+                                throw new TranslationException(containedType, "Invalid contained type: " + containedType);
+                        }
+                        var newInfo = currentInfo.addSupertype(ContainmentHierarchyTranslator.CONTAINED_SYMBOL);
+                        typeInfoMap.put(containedType, newInfo);
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/Metamodel.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/Metamodel.java
new file mode 100644
index 00000000..72b836ff
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/Metamodel.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.metamodel;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.containment.ContainmentInfo;
+import tools.refinery.store.reasoning.translator.crossreference.DirectedCrossReferenceInfo;
+import tools.refinery.store.reasoning.translator.crossreference.UndirectedCrossReferenceInfo;
+import tools.refinery.store.reasoning.translator.typehierarchy.TypeHierarchy;
+
+import java.util.Map;
+
+public record Metamodel(TypeHierarchy typeHierarchy, Map<PartialRelation, ContainmentInfo> containmentHierarchy,
+                                                Map<PartialRelation, DirectedCrossReferenceInfo> directedCrossReferences,
+                                                Map<PartialRelation, UndirectedCrossReferenceInfo> undirectedCrossReferences,
+                                                Map<PartialRelation, PartialRelation> oppositeReferences) {
+        public static MetamodelBuilder builder() {
+                return new MetamodelBuilder();
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
new file mode 100644
index 00000000..ad0288ed
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelBuilder.java
@@ -0,0 +1,225 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.metamodel;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
+import tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator;
+import tools.refinery.store.reasoning.translator.containment.ContainmentInfo;
+import tools.refinery.store.reasoning.translator.crossreference.DirectedCrossReferenceInfo;
+import tools.refinery.store.reasoning.translator.crossreference.UndirectedCrossReferenceInfo;
+import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
+import tools.refinery.store.reasoning.translator.multiplicity.UnconstrainedMultiplicity;
+import tools.refinery.store.reasoning.translator.typehierarchy.TypeInfo;
+
+import java.util.*;
+
+public class MetamodelBuilder {
+        private final ContainedTypeHierarchyBuilder typeHierarchyBuilder = new ContainedTypeHierarchyBuilder();
+        private final Map<PartialRelation, ReferenceInfo> referenceInfoMap = new LinkedHashMap<>();
+        private final Set<PartialRelation> containedTypes = new HashSet<>();
+        private final Map<PartialRelation, ContainmentInfo> containmentHierarchy = new LinkedHashMap<>();
+        private final Map<PartialRelation, DirectedCrossReferenceInfo> directedCrossReferences = new LinkedHashMap<>();
+        private final Map<PartialRelation, UndirectedCrossReferenceInfo> undirectedCrossReferences = new LinkedHashMap<>();
+        private final Map<PartialRelation, PartialRelation> oppositeReferences = new LinkedHashMap<>();
+
+        MetamodelBuilder() {
+                typeHierarchyBuilder.type(ContainmentHierarchyTranslator.CONTAINED_SYMBOL, true);
+        }
+
+        public MetamodelBuilder type(PartialRelation partialRelation, TypeInfo typeInfo) {
+                typeHierarchyBuilder.type(partialRelation, typeInfo);
+                return this;
+
+        }
+
+        public MetamodelBuilder type(PartialRelation partialRelation, boolean abstractType,
+                                                                 PartialRelation... supertypes) {
+                typeHierarchyBuilder.type(partialRelation, abstractType, supertypes);
+                return this;
+        }
+
+        public MetamodelBuilder type(PartialRelation partialRelation, boolean abstractType,
+                                                                 Collection<PartialRelation> supertypes) {
+                typeHierarchyBuilder.type(partialRelation, abstractType, supertypes);
+                return this;
+        }
+
+        public MetamodelBuilder type(PartialRelation partialRelation, PartialRelation... supertypes) {
+                typeHierarchyBuilder.type(partialRelation, supertypes);
+                return this;
+        }
+
+        public MetamodelBuilder type(PartialRelation partialRelation, Collection<PartialRelation> supertypes) {
+                typeHierarchyBuilder.type(partialRelation, supertypes);
+                return this;
+        }
+
+        public MetamodelBuilder types(Collection<Map.Entry<PartialRelation, TypeInfo>> entries) {
+                typeHierarchyBuilder.types(entries);
+                return this;
+        }
+
+        public MetamodelBuilder types(Map<PartialRelation, TypeInfo> map) {
+                typeHierarchyBuilder.types(map);
+                return this;
+        }
+
+        public MetamodelBuilder reference(PartialRelation linkType, ReferenceInfo info) {
+                if (linkType.arity() != 2) {
+                        throw new TranslationException(linkType,
+                                        "Only references of arity 2 are supported, got %s with %d instead".formatted(
+                                                        linkType, linkType.arity()));
+                }
+                var putResult = referenceInfoMap.put(linkType, info);
+                if (putResult != null && !putResult.equals(info)) {
+                        throw new TranslationException(linkType, "Duplicate reference info for partial relation: " + linkType);
+                }
+                return this;
+        }
+
+        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType, boolean containment,
+                                                                          Multiplicity multiplicity, PartialRelation targetType,
+                                                                          PartialRelation opposite) {
+                return reference(linkType, new ReferenceInfo(containment, sourceType, multiplicity, targetType, opposite));
+        }
+
+        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType, Multiplicity multiplicity,
+                                                                          PartialRelation targetType, PartialRelation opposite) {
+                return reference(linkType, sourceType, false, multiplicity, targetType, opposite);
+        }
+
+        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType,
+                                                                          boolean containment, PartialRelation targetType, PartialRelation opposite) {
+                return reference(linkType, sourceType, containment, UnconstrainedMultiplicity.INSTANCE, targetType, opposite);
+        }
+
+        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType, PartialRelation targetType,
+                                                                          PartialRelation opposite) {
+                return reference(linkType, sourceType, UnconstrainedMultiplicity.INSTANCE, targetType, opposite);
+        }
+
+        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType, boolean containment,
+                                                                          Multiplicity multiplicity, PartialRelation targetType) {
+                return reference(linkType, sourceType, containment, multiplicity, targetType, null);
+        }
+
+        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType, Multiplicity multiplicity,
+                                                                          PartialRelation targetType) {
+                return reference(linkType, sourceType, multiplicity, targetType, null);
+        }
+
+        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType, boolean containment,
+                                                                          PartialRelation targetType) {
+                return reference(linkType, sourceType, containment, targetType, null);
+        }
+
+        public MetamodelBuilder reference(PartialRelation linkType, PartialRelation sourceType,
+                                                                          PartialRelation targetType) {
+                return reference(linkType, sourceType, targetType, null);
+        }
+
+        public MetamodelBuilder references(Collection<Map.Entry<PartialRelation, ReferenceInfo>> entries) {
+                for (var entry : entries) {
+                        reference(entry.getKey(), entry.getValue());
+                }
+                return this;
+        }
+
+        public MetamodelBuilder references(Map<PartialRelation, ReferenceInfo> map) {
+                return references(map.entrySet());
+        }
+
+        public Metamodel build() {
+                for (var entry : referenceInfoMap.entrySet()) {
+                        var linkType = entry.getKey();
+                        var info = entry.getValue();
+                        processReferenceInfo(linkType, info);
+                }
+                typeHierarchyBuilder.setContainedTypes(containedTypes);
+                var typeHierarchy = typeHierarchyBuilder.build();
+                return new Metamodel(typeHierarchy, Collections.unmodifiableMap(containmentHierarchy),
+                                Collections.unmodifiableMap(directedCrossReferences),
+                                Collections.unmodifiableMap(undirectedCrossReferences),
+                                Collections.unmodifiableMap(oppositeReferences));
+        }
+
+        private void processReferenceInfo(PartialRelation linkType, ReferenceInfo info) {
+                if (oppositeReferences.containsKey(linkType) || containmentHierarchy.containsKey(linkType)) {
+                        // We already processed this reference while processing its opposite.
+                        return;
+                }
+                var sourceType = info.sourceType();
+                var targetType = info.targetType();
+                if (typeHierarchyBuilder.isInvalidType(sourceType)) {
+                        throw new TranslationException(linkType, "Source type %s of %s is not in type hierarchy"
+                                        .formatted(sourceType, linkType));
+                }
+                if (typeHierarchyBuilder.isInvalidType(targetType)) {
+                        throw new TranslationException(linkType, "Target type %s of %s is not in type hierarchy"
+                                        .formatted(targetType, linkType));
+                }
+                var opposite = info.opposite();
+                Multiplicity targetMultiplicity = UnconstrainedMultiplicity.INSTANCE;
+                if (opposite != null) {
+                        var oppositeInfo = referenceInfoMap.get(opposite);
+                        validateOpposite(linkType, info, opposite, oppositeInfo);
+                        targetMultiplicity = oppositeInfo.multiplicity();
+                        if (oppositeInfo.containment()) {
+                                // Skip processing this reference and process it once we encounter its containment opposite.
+                                return;
+                        }
+                        if (opposite.equals(linkType)) {
+                                if (!sourceType.equals(targetType)) {
+                                        throw new TranslationException(linkType,
+                                                        "Target %s of undirected reference %s differs from source %s".formatted(
+                                                                        targetType, linkType, sourceType));
+                                }
+                                undirectedCrossReferences.put(linkType, new UndirectedCrossReferenceInfo(sourceType,
+                                                info.multiplicity()));
+                                return;
+                        }
+                        oppositeReferences.put(opposite, linkType);
+                }
+                if (info.containment()) {
+                        if (!UnconstrainedMultiplicity.INSTANCE.equals(targetMultiplicity)) {
+                                throw new TranslationException(opposite, "Invalid opposite %s with multiplicity %s of containment %s"
+                                                .formatted(opposite, targetMultiplicity, linkType));
+                        }
+                        containedTypes.add(targetType);
+                        containmentHierarchy.put(linkType, new ContainmentInfo(sourceType, info.multiplicity(), targetType));
+                        return;
+                }
+                directedCrossReferences.put(linkType, new DirectedCrossReferenceInfo(sourceType, info.multiplicity(),
+                                targetType, targetMultiplicity));
+        }
+
+        private static void validateOpposite(PartialRelation linkType, ReferenceInfo info, PartialRelation opposite,
+                                                                                 ReferenceInfo oppositeInfo) {
+                var sourceType = info.sourceType();
+                var targetType = info.targetType();
+                if (oppositeInfo == null) {
+                        throw new TranslationException(linkType, "Opposite %s of %s is not defined"
+                                        .formatted(opposite, linkType));
+                }
+                if (!linkType.equals(oppositeInfo.opposite())) {
+                        throw new TranslationException(opposite, "Expected %s to have opposite %s, got %s instead"
+                                        .formatted(opposite, linkType, oppositeInfo.opposite()));
+                }
+                if (!targetType.equals(oppositeInfo.sourceType())) {
+                        throw new TranslationException(linkType, "Expected %s to have source type %s, got %s instead"
+                                        .formatted(opposite, targetType, oppositeInfo.sourceType()));
+                }
+                if (!sourceType.equals(oppositeInfo.targetType())) {
+                        throw new TranslationException(linkType, "Expected %s to have target type %s, got %s instead"
+                                        .formatted(opposite, sourceType, oppositeInfo.targetType()));
+                }
+                if (oppositeInfo.containment() && info.containment()) {
+                        throw new TranslationException(opposite, "Opposite %s of containment %s cannot be containment"
+                                        .formatted(opposite, linkType));
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTranslator.java
new file mode 100644
index 00000000..5afa58f2
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTranslator.java
@@ -0,0 +1,37 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.metamodel;
+
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.model.ModelStoreConfiguration;
+import tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator;
+import tools.refinery.store.reasoning.translator.crossreference.DirectedCrossReferenceTranslator;
+import tools.refinery.store.reasoning.translator.crossreference.UndirectedCrossReferenceTranslator;
+import tools.refinery.store.reasoning.translator.opposite.OppositeRelationTranslator;
+import tools.refinery.store.reasoning.translator.typehierarchy.TypeHierarchyTranslator;
+
+public class MetamodelTranslator implements ModelStoreConfiguration {
+        private final Metamodel metamodel;
+
+        public MetamodelTranslator(Metamodel metamodel) {
+                this.metamodel = metamodel;
+        }
+
+        @Override
+        public void apply(ModelStoreBuilder storeBuilder) {
+                storeBuilder.with(new TypeHierarchyTranslator(metamodel.typeHierarchy()));
+                storeBuilder.with(new ContainmentHierarchyTranslator(metamodel.containmentHierarchy()));
+                for (var entry : metamodel.directedCrossReferences().entrySet()) {
+                        storeBuilder.with(new DirectedCrossReferenceTranslator(entry.getKey(), entry.getValue()));
+                }
+                for (var entry : metamodel.undirectedCrossReferences().entrySet()) {
+                        storeBuilder.with(new UndirectedCrossReferenceTranslator(entry.getKey(), entry.getValue()));
+                }
+                for (var entry : metamodel.oppositeReferences().entrySet()) {
+                        storeBuilder.with(new OppositeRelationTranslator(entry.getKey(), entry.getValue()));
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ReferenceInfo.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ReferenceInfo.java
new file mode 100644
index 00000000..9a6b4012
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/metamodel/ReferenceInfo.java
@@ -0,0 +1,13 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.metamodel;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
+
+public record ReferenceInfo(boolean containment, PartialRelation sourceType, Multiplicity multiplicity,
+                                                        PartialRelation targetType, PartialRelation opposite) {
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/EqualsRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/EqualsRefiner.java
new file mode 100644
index 00000000..d8db4ec4
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/EqualsRefiner.java
@@ -0,0 +1,64 @@
+/*
+ * 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.model.Interpretation;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.refinement.AbstractPartialInterpretationRefiner;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.representation.cardinality.CardinalityInterval;
+import tools.refinery.store.representation.cardinality.CardinalityIntervals;
+import tools.refinery.store.tuple.Tuple;
+
+public class EqualsRefiner extends AbstractPartialInterpretationRefiner<TruthValue, Boolean> {
+        private final Interpretation<CardinalityInterval> countInterpretation;
+
+        private EqualsRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
+                          Symbol<CardinalityInterval> countSymbol) {
+                super(adapter, partialSymbol);
+                countInterpretation = adapter.getModel().getInterpretation(countSymbol);
+        }
+
+        @Override
+        public boolean merge(Tuple key, TruthValue value) {
+                if (value == TruthValue.UNKNOWN) {
+                        return true;
+                }
+                if (value == TruthValue.ERROR) {
+                        return false;
+                }
+                int left = key.get(0);
+                int right = key.get(1);
+                boolean isDiagonal = left == right;
+                if (isDiagonal && value == TruthValue.FALSE) {
+                        return false;
+                }
+                if (!isDiagonal) {
+                        return !value.may();
+                }
+                if (value != TruthValue.TRUE) {
+                        throw new IllegalArgumentException("Unknown TruthValue: " + value);
+                }
+                // {@code isDiagonal} is true, so this could be {@code left} or {@code right}.
+                var unaryKey = Tuple.of(left);
+                var currentCount = countInterpretation.get(unaryKey);
+                if (currentCount == null) {
+                        return false;
+                }
+                var newCount = currentCount.meet(CardinalityIntervals.LONE);
+                if (newCount.isEmpty()) {
+                        return false;
+                }
+                countInterpretation.put(unaryKey, newCount);
+                return true;
+        }
+
+        public static Factory<TruthValue, Boolean> of(Symbol<CardinalityInterval> countSymbol) {
+                return (adapter, partialSymbol) -> new EqualsRefiner(adapter, partialSymbol, countSymbol);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/EqualsRelationRewriter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/EqualsRelationRewriter.java
new file mode 100644
index 00000000..61b9488c
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/EqualsRelationRewriter.java
@@ -0,0 +1,85 @@
+/*
+ * 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.dnf.Query;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.literal.AbstractCallLiteral;
+import tools.refinery.store.query.literal.CallLiteral;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.view.AnySymbolView;
+import tools.refinery.store.reasoning.interpretation.QueryBasedRelationRewriter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.literal.Modality;
+import tools.refinery.store.representation.cardinality.UpperCardinalities;
+import tools.refinery.store.representation.cardinality.UpperCardinality;
+
+import java.util.List;
+import java.util.Set;
+
+import static tools.refinery.store.query.literal.Literals.check;
+import static tools.refinery.store.query.term.uppercardinality.UpperCardinalityTerms.constant;
+import static tools.refinery.store.query.term.uppercardinality.UpperCardinalityTerms.lessEq;
+
+class EqualsRelationRewriter extends QueryBasedRelationRewriter {
+        private EqualsRelationRewriter(RelationalQuery may, RelationalQuery must) {
+                super(may, must, may, may);
+        }
+
+        @Override
+        public List<Literal> rewriteLiteral(Set<Variable> positiveVariables, AbstractCallLiteral literal,
+                                                                                Modality modality, Concreteness concreteness) {
+                if (!(literal instanceof CallLiteral callLiteral)) {
+                        return super.rewriteLiteral(positiveVariables, literal, modality, concreteness);
+                }
+                var left = callLiteral.getArguments().get(0).asNodeVariable();
+                var right = callLiteral.getArguments().get(1).asNodeVariable();
+                boolean useMay = modality == Modality.MAY || concreteness == Concreteness.CANDIDATE;
+                return switch (callLiteral.getPolarity()) {
+                        case POSITIVE, TRANSITIVE -> {
+                                if (useMay) {
+                                        if (positiveVariables.contains(left) || positiveVariables.contains(right)) {
+                                                // No need to enumerate arguments if at least one is already bound, since they will be unified.
+                                                yield List.of(left.isEquivalent(right));
+                                        } else {
+                                                yield List.of(
+                                                                left.isEquivalent(right),
+                                                                getMay().call(left, right)
+                                                );
+                                        }
+                                } else {
+                                        yield List.of(
+                                                        left.isEquivalent(right),
+                                                        getMust().call(left, right)
+                                        );
+                                }
+                        }
+                        case NEGATIVE -> {
+                                if (useMay) {
+                                        yield List.of(left.notEquivalent(right));
+                                } else {
+                                        yield super.rewriteLiteral(positiveVariables, literal, modality, concreteness);
+                                }
+                        }
+                };
+        }
+
+        public static EqualsRelationRewriter of(AnySymbolView upperCardinalityView) {
+                var may = Query.of("equals#may", (builder, p1, p2) -> builder
+                                .clause(
+                                                p1.isEquivalent(p2),
+                                                upperCardinalityView.call(p1, Variable.of(UpperCardinality.class))
+                                ));
+                var must = Query.of("equals#must", (builder, p1, p2) -> builder
+                                .clause(UpperCardinality.class, upper -> List.of(
+                                                p1.isEquivalent(p2),
+                                                upperCardinalityView.call(p1, upper),
+                                                check(lessEq(upper, constant(UpperCardinalities.ONE)))
+                                )));
+                return new EqualsRelationRewriter(may, must);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/ExistsRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/ExistsRefiner.java
new file mode 100644
index 00000000..f134fe92
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/ExistsRefiner.java
@@ -0,0 +1,55 @@
+/*
+ * 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.model.Interpretation;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.refinement.AbstractPartialInterpretationRefiner;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.representation.cardinality.CardinalityInterval;
+import tools.refinery.store.representation.cardinality.CardinalityIntervals;
+import tools.refinery.store.tuple.Tuple;
+
+public class ExistsRefiner extends AbstractPartialInterpretationRefiner<TruthValue, Boolean> {
+        private final Interpretation<CardinalityInterval> countInterpretation;
+
+        private ExistsRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
+                                                   Symbol<CardinalityInterval> countSymbol) {
+                super(adapter, partialSymbol);
+                countInterpretation = adapter.getModel().getInterpretation(countSymbol);
+        }
+
+        @Override
+        public boolean merge(Tuple key, TruthValue value) {
+                var currentCount = countInterpretation.get(key);
+                if (currentCount == null) {
+                        return false;
+                }
+                CardinalityInterval newCount;
+                switch (value) {
+                case UNKNOWN -> {
+                        return true;
+                }
+                case TRUE -> newCount = currentCount.meet(CardinalityIntervals.SOME);
+                case FALSE -> newCount = currentCount.meet(CardinalityIntervals.NONE);
+                case ERROR -> {
+                        return false;
+                }
+                default -> throw new IllegalArgumentException("Unknown TruthValue: " + value);
+                }
+                if (newCount.isEmpty()) {
+                        return false;
+                }
+                countInterpretation.put(key, newCount);
+                return true;
+        }
+
+        public static Factory<TruthValue, Boolean> of(Symbol<CardinalityInterval> countSymbol) {
+                return (adapter, partialSymbol) -> new ExistsRefiner(adapter, partialSymbol, countSymbol);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/LowerCardinalityView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/LowerCardinalityView.java
new file mode 100644
index 00000000..9873888c
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/LowerCardinalityView.java
@@ -0,0 +1,22 @@
+/*
+ * 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.term.Parameter;
+import tools.refinery.store.query.view.AbstractFunctionView;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.cardinality.CardinalityInterval;
+
+class LowerCardinalityView extends AbstractFunctionView<CardinalityInterval> {
+        public LowerCardinalityView(Symbol<CardinalityInterval> symbol) {
+                super(symbol, "lower", new Parameter(Integer.class));
+        }
+
+        @Override
+        protected Object forwardMapValue(CardinalityInterval value) {
+                return value.lowerBound();
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectInitializer.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectInitializer.java
new file mode 100644
index 00000000..89918155
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectInitializer.java
@@ -0,0 +1,135 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.multiobject;
+
+import org.jetbrains.annotations.NotNull;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
+import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.reasoning.translator.TranslationException;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.representation.cardinality.CardinalityInterval;
+import tools.refinery.store.representation.cardinality.CardinalityIntervals;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.function.Function;
+
+class MultiObjectInitializer implements PartialModelInitializer {
+        private final Symbol<CardinalityInterval> countSymbol;
+
+        public MultiObjectInitializer(Symbol<CardinalityInterval> countSymbol) {
+                this.countSymbol = countSymbol;
+        }
+
+        @Override
+        public void initialize(Model model, ModelSeed modelSeed) {
+                var intervals = initializeIntervals(model, modelSeed);
+                initializeExists(intervals, model, modelSeed);
+                initializeEquals(intervals, model, modelSeed);
+                var countInterpretation = model.getInterpretation(countSymbol);
+                var uniqueTable = new HashMap<CardinalityInterval, CardinalityInterval>();
+                for (int i = 0; i < intervals.length; i++) {
+                        var interval = intervals[i];
+                        if (interval.isEmpty()) {
+                                throw new TranslationException(ReasoningAdapter.EXISTS_SYMBOL,
+                                                "Inconsistent existence or equality for node " + i);
+                        }
+                        var uniqueInterval = uniqueTable.computeIfAbsent(intervals[i], Function.identity());
+                        countInterpretation.put(Tuple.of(i), uniqueInterval);
+                }
+        }
+
+        @NotNull
+        private CardinalityInterval[] initializeIntervals(Model model, ModelSeed modelSeed) {
+                var intervals = new CardinalityInterval[modelSeed.getNodeCount()];
+                if (modelSeed.containsSeed(MultiObjectTranslator.COUNT_SYMBOL)) {
+                        Arrays.fill(intervals, CardinalityIntervals.ONE);
+                        var cursor = modelSeed.getCursor(MultiObjectTranslator.COUNT_SYMBOL, CardinalityIntervals.ONE);
+                        while (cursor.move()) {
+                                model.checkCancelled();
+                                int i = cursor.getKey().get(0);
+                                checkNodeId(intervals, i);
+                                intervals[i] = cursor.getValue();
+                        }
+                } else {
+                        Arrays.fill(intervals, CardinalityIntervals.SET);
+                        if (!modelSeed.containsSeed(ReasoningAdapter.EXISTS_SYMBOL) ||
+                                        !modelSeed.containsSeed(ReasoningAdapter.EQUALS_SYMBOL)) {
+                                throw new TranslationException(MultiObjectTranslator.COUNT_SYMBOL,
+                                                "Seed for %s and %s is required if there is no seed for %s".formatted(
+                                                                ReasoningAdapter.EXISTS_SYMBOL, ReasoningAdapter.EQUALS_SYMBOL,
+                                                                MultiObjectTranslator.COUNT_SYMBOL));
+                        }
+                }
+                return intervals;
+        }
+
+        private void initializeExists(CardinalityInterval[] intervals, Model model, ModelSeed modelSeed) {
+                if (!modelSeed.containsSeed(ReasoningAdapter.EXISTS_SYMBOL)) {
+                        return;
+                }
+                var cursor = modelSeed.getCursor(ReasoningAdapter.EXISTS_SYMBOL, TruthValue.UNKNOWN);
+                while (cursor.move()) {
+                        model.checkCancelled();
+                        int i = cursor.getKey().get(0);
+                        checkNodeId(intervals, i);
+                        switch (cursor.getValue()) {
+                        case TRUE -> intervals[i] = intervals[i].meet(CardinalityIntervals.SOME);
+                        case FALSE -> intervals[i] = intervals[i].meet(CardinalityIntervals.NONE);
+                        case ERROR -> throw new TranslationException(ReasoningAdapter.EXISTS_SYMBOL,
+                                        "Inconsistent existence for node " + i);
+                        default -> throw new TranslationException(ReasoningAdapter.EXISTS_SYMBOL,
+                                        "Invalid existence truth value %s for node %d".formatted(cursor.getValue(), i));
+                        }
+                }
+        }
+
+        private void initializeEquals(CardinalityInterval[] intervals, Model model, ModelSeed modelSeed) {
+                if (!modelSeed.containsSeed(ReasoningAdapter.EQUALS_SYMBOL)) {
+                        return;
+                }
+                var seed = modelSeed.getSeed(ReasoningAdapter.EQUALS_SYMBOL);
+                var cursor = seed.getCursor(TruthValue.FALSE, modelSeed.getNodeCount());
+                while (cursor.move()) {
+                        model.checkCancelled();
+                        var key = cursor.getKey();
+                        int i = key.get(0);
+                        int otherIndex = key.get(1);
+                        if (i != otherIndex) {
+                                throw new TranslationException(ReasoningAdapter.EQUALS_SYMBOL,
+                                                "Off-diagonal equivalence (%d, %d) is not permitted".formatted(i, otherIndex));
+                        }
+                        checkNodeId(intervals, i);
+                        switch (cursor.getValue()) {
+                        case TRUE -> intervals[i] = intervals[i].meet(CardinalityIntervals.LONE);
+                        case UNKNOWN -> {
+                                // Nothing do to, {@code intervals} is initialized with unknown equality.
+                        }
+                        case ERROR -> throw new TranslationException(ReasoningAdapter.EQUALS_SYMBOL,
+                                        "Inconsistent equality for node " + i);
+                        default -> throw new TranslationException(ReasoningAdapter.EQUALS_SYMBOL,
+                                        "Invalid equality truth value %s for node %d".formatted(cursor.getValue(), i));
+                        }
+                }
+                for (int i = 0; i < intervals.length; i++) {
+                        model.checkCancelled();
+                        if (seed.get(Tuple.of(i, i)) == TruthValue.FALSE) {
+                                throw new TranslationException(ReasoningAdapter.EQUALS_SYMBOL, "Inconsistent equality for node " + i);
+                        }
+                }
+        }
+
+        private void checkNodeId(CardinalityInterval[] intervals, int nodeId) {
+                if (nodeId < 0 || nodeId >= intervals.length) {
+                        throw new IllegalArgumentException("Expected node id %d to be lower than model size %d"
+                                        .formatted(nodeId, intervals.length));
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectStorageRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectStorageRefiner.java
new file mode 100644
index 00000000..e48934d8
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectStorageRefiner.java
@@ -0,0 +1,45 @@
+/*
+ * 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.model.Interpretation;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.refinement.StorageRefiner;
+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 MultiObjectStorageRefiner implements StorageRefiner {
+        private final Interpretation<CardinalityInterval> countInterpretation;
+
+        public MultiObjectStorageRefiner(Symbol<CardinalityInterval> countSymbol, Model model) {
+                countInterpretation = model.getInterpretation(countSymbol);
+        }
+
+        @Override
+        public boolean split(int parentNode, int childNode) {
+                var parentKey = Tuple.of(parentNode);
+                var parentCount = countInterpretation.get(parentKey);
+                if (parentCount == null) {
+                        return false;
+                }
+                var newParentCount = parentCount.take(1);
+                if (newParentCount.isEmpty()) {
+                        return false;
+                }
+                var childKey = Tuple.of(childNode);
+                countInterpretation.put(parentKey, newParentCount);
+                countInterpretation.put(childKey, CardinalityIntervals.ONE);
+                return true;
+        }
+
+        @Override
+        public boolean cleanup(int nodeToDelete) {
+                var previousCount = countInterpretation.put(Tuple.of(nodeToDelete), null);
+                return previousCount.lowerBound() == 0;
+        }
+}
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
new file mode 100644
index 00000000..97fda9d5
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectTranslator.java
@@ -0,0 +1,107 @@
+/*
+ * 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.dse.propagation.PropagationBuilder;
+import tools.refinery.store.dse.transition.Rule;
+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.literal.Literals;
+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;
+import tools.refinery.store.reasoning.actions.PartialActionLiterals;
+import tools.refinery.store.reasoning.representation.PartialFunction;
+import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.reasoning.translator.RoundingMode;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.cardinality.CardinalityDomain;
+import tools.refinery.store.representation.cardinality.CardinalityInterval;
+import tools.refinery.store.representation.cardinality.UpperCardinalities;
+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.*;
+
+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);
+
+        @Override
+        public void apply(ModelStoreBuilder storeBuilder) {
+                storeBuilder.symbol(COUNT_STORAGE);
+
+                var aboveLowerBound = Query.of("count#aboveLowerBound", Integer.class, (builder, node, output) -> builder
+                                .clause(
+                                                MULTI_VIEW.call(node),
+                                                LOWER_CARDINALITY_VIEW.call(node, output),
+                                                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(UpperCardinalityTerms.greaterEq(upper,
+                                                                                UpperCardinalityTerms.constant(UpperCardinalities.ONE)))
+                                                ))))
+                                .must(Query.of("exists#must", (builder, p1) -> builder
+                                                .clause(Integer.class, lower -> List.of(
+                                                                LOWER_CARDINALITY_VIEW.call(p1, lower),
+                                                                check(greaterEq(lower, constant(1)))
+                                                ))))
+                                .candidate(Query.of("exists#candidate", (builder, p1) -> builder
+                                                .clause(
+                                                                LOWER_CARDINALITY_VIEW.call(p1, Variable.of(Integer.class)),
+                                                                Literals.not(MULTI_VIEW.call(p1))
+                                                )))
+                                .roundingMode(RoundingMode.PREFER_FALSE)
+                                .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))
+                                .exclude(null)
+                                .accept(null)
+                                .objective(null));
+
+                var reasoningBuilder = storeBuilder.getAdapter(ReasoningBuilder.class);
+                reasoningBuilder.initializer(new MultiObjectInitializer(COUNT_STORAGE));
+                reasoningBuilder.storageRefiner(COUNT_STORAGE, MultiObjectStorageRefiner::new);
+
+                storeBuilder.tryGetAdapter(PropagationBuilder.class)
+                                .ifPresent(propagationBuilder -> propagationBuilder.rule(
+                                                Rule.of("exists#cleanup", (builder, node) -> builder
+                                                                .clause(UpperCardinality.class, upper -> List.of(
+                                                                                UPPER_CARDINALITY_VIEW.call(node, upper),
+                                                                                check(UpperCardinalityTerms.less(upper,
+                                                                                                UpperCardinalityTerms.constant(UpperCardinalities.ONE)))
+                                                                ))
+                                                                .action(
+                                                                                PartialActionLiterals.cleanup(node)
+                                                                ))));
+        }
+}
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/multiobject/UpperCardinalityView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/UpperCardinalityView.java
new file mode 100644
index 00000000..6be6ae1b
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/UpperCardinalityView.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.term.Parameter;
+import tools.refinery.store.query.view.AbstractFunctionView;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.cardinality.CardinalityInterval;
+import tools.refinery.store.representation.cardinality.UpperCardinality;
+
+class UpperCardinalityView extends AbstractFunctionView<CardinalityInterval> {
+        public UpperCardinalityView(Symbol<CardinalityInterval> symbol) {
+                super(symbol, "upper", new Parameter(UpperCardinality.class));
+        }
+
+        @Override
+        protected Object forwardMapValue(CardinalityInterval value) {
+                return value.upperBound();
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/ConstrainedMultiplicity.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/ConstrainedMultiplicity.java
new file mode 100644
index 00000000..9db9cc96
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/ConstrainedMultiplicity.java
@@ -0,0 +1,37 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.multiplicity;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
+import tools.refinery.store.representation.cardinality.CardinalityInterval;
+import tools.refinery.store.representation.cardinality.CardinalityIntervals;
+import tools.refinery.store.representation.cardinality.NonEmptyCardinalityInterval;
+
+public record ConstrainedMultiplicity(NonEmptyCardinalityInterval multiplicity, PartialRelation errorSymbol)
+                implements Multiplicity {
+        public ConstrainedMultiplicity {
+                if (multiplicity.equals(CardinalityIntervals.SET)) {
+                        throw new TranslationException(errorSymbol, "Expected a constrained cardinality interval");
+                }
+                if (errorSymbol.arity() != 1) {
+                        throw new TranslationException(errorSymbol, "Expected error symbol %s to have arity 1, got %d instead"
+                                        .formatted(errorSymbol, errorSymbol.arity()));
+                }
+        }
+
+        public static ConstrainedMultiplicity of(CardinalityInterval multiplicity, PartialRelation errorSymbol) {
+                if (!(multiplicity instanceof NonEmptyCardinalityInterval nonEmptyCardinalityInterval)) {
+                        throw new TranslationException(errorSymbol, "Inconsistent multiplicity");
+                }
+                return new ConstrainedMultiplicity(nonEmptyCardinalityInterval, errorSymbol);
+        }
+
+        @Override
+        public boolean isConstrained() {
+                return true;
+        }
+}
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
new file mode 100644
index 00000000..ba208156
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/InvalidMultiplicityErrorTranslator.java
@@ -0,0 +1,141 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+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;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.term.int_.IntTerms;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.lifting.DnfLifter;
+import tools.refinery.store.reasoning.literal.*;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.reasoning.translator.TranslationException;
+import tools.refinery.store.representation.cardinality.FiniteUpperCardinality;
+import tools.refinery.store.representation.cardinality.UpperCardinalities;
+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;
+import static tools.refinery.store.reasoning.literal.PartialLiterals.must;
+
+public class InvalidMultiplicityErrorTranslator implements ModelStoreConfiguration {
+        private final PartialRelation nodeType;
+        private final PartialRelation linkType;
+        private final boolean inverse;
+        private final Multiplicity multiplicity;
+
+        public InvalidMultiplicityErrorTranslator(PartialRelation nodeType, PartialRelation linkType,
+                                                                                          boolean inverse, Multiplicity multiplicity) {
+                if (nodeType.arity() != 1) {
+                        throw new TranslationException(linkType, "Node type must be of arity 1, got %s with arity %d instead"
+                                        .formatted(nodeType, nodeType.arity()));
+                }
+                if (linkType.arity() != 2) {
+                        throw new TranslationException(linkType, "Link type must be of arity 2, got %s with arity %d instead"
+                                        .formatted(linkType, linkType.arity()));
+                }
+                this.nodeType = nodeType;
+                this.linkType = linkType;
+                this.inverse = inverse;
+                this.multiplicity = multiplicity;
+        }
+
+        @Override
+        public void apply(ModelStoreBuilder storeBuilder) {
+                if (!(multiplicity instanceof ConstrainedMultiplicity constrainedMultiplicity)) {
+                        return;
+                }
+
+                var name = constrainedMultiplicity.errorSymbol().name();
+                var cardinalityInterval = constrainedMultiplicity.multiplicity();
+                var node = Variable.of("node");
+                var other = Variable.of("other");
+                List<Variable> arguments = inverse ? List.of(other, node) : List.of(node, other);
+                var mustBuilder = Query.builder(DnfLifter.decorateName(name, Modality.MUST, Concreteness.PARTIAL))
+                                .parameter(node);
+                var candidateMayBuilder = Query.builder(DnfLifter.decorateName(name, Modality.MAY, Concreteness.PARTIAL))
+                                .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) {
+                        var lowerBoundCardinality = UpperCardinalities.atMost(lowerBound);
+                        mustBuilder.clause(UpperCardinality.class, existingContents -> List.of(
+                                        must(nodeType.call(node)),
+                                        new CountUpperBoundLiteral(existingContents, linkType, arguments),
+                                        check(less(existingContents, constant(lowerBoundCardinality)))
+                        ));
+                        candidateMayBuilder.clause(Integer.class, existingContents -> List.of(
+                                        candidateMust(nodeType.call(node)),
+                                        new CountCandidateLowerBoundLiteral(existingContents, linkType, arguments),
+                                        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, 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)))
+                        ));
+                }
+
+                if (cardinalityInterval.upperBound() instanceof FiniteUpperCardinality finiteUpperCardinality) {
+                        int upperBound = finiteUpperCardinality.finiteUpperBound();
+                        mustBuilder.clause(Integer.class, existingContents -> List.of(
+                                        must(nodeType.call(node)),
+                                        new CountLowerBoundLiteral(existingContents, linkType, arguments),
+                                        check(greater(existingContents, constant(upperBound)))
+                        ));
+                        candidateMayBuilder.clause(Integer.class, existingContents -> List.of(
+                                        candidateMust(nodeType.call(node)),
+                                        new CountCandidateUpperBoundLiteral(existingContents, linkType, arguments),
+                                        check(greater(existingContents, constant(upperBound)))
+                        ));
+                        candidateMustBuilder.clause(Integer.class, existingContents -> List.of(
+                                        candidateMust(nodeType.call(node)),
+                                        new CountCandidateLowerBoundLiteral(existingContents, linkType, arguments),
+                                        check(greater(existingContents, constant(upperBound)))
+                        ));
+                        missingBuilder.clause(Integer.class, existingContents -> List.of(
+                                        candidateMust(nodeType.call(node)),
+                                        candidateMust(ReasoningAdapter.EXISTS_SYMBOL.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())
+                                .objective(Objectives.value(objective)));
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/Multiplicity.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/Multiplicity.java
new file mode 100644
index 00000000..d1d6dd1e
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/Multiplicity.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.multiplicity;
+
+import tools.refinery.store.representation.cardinality.CardinalityInterval;
+
+public sealed interface Multiplicity permits ConstrainedMultiplicity, UnconstrainedMultiplicity {
+        CardinalityInterval multiplicity();
+
+        boolean isConstrained();
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/UnconstrainedMultiplicity.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/UnconstrainedMultiplicity.java
new file mode 100644
index 00000000..2159b88c
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiplicity/UnconstrainedMultiplicity.java
@@ -0,0 +1,28 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.multiplicity;
+
+import tools.refinery.store.representation.cardinality.CardinalityInterval;
+import tools.refinery.store.representation.cardinality.CardinalityIntervals;
+
+// Singleton implementation, because there is only a single complete interval.
+@SuppressWarnings("squid:S6548")
+public final class UnconstrainedMultiplicity implements Multiplicity {
+        public static final UnconstrainedMultiplicity INSTANCE = new UnconstrainedMultiplicity();
+
+        private UnconstrainedMultiplicity() {
+        }
+
+        @Override
+        public CardinalityInterval multiplicity() {
+                return CardinalityIntervals.SET;
+        }
+
+        @Override
+        public boolean isConstrained() {
+                return true;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeInterpretation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeInterpretation.java
new file mode 100644
index 00000000..7290ab40
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeInterpretation.java
@@ -0,0 +1,77 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.opposite;
+
+
+import tools.refinery.store.map.AnyVersionedMap;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.interpretation.AbstractPartialInterpretation;
+import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Set;
+
+class OppositeInterpretation<A, C> extends AbstractPartialInterpretation<A, C> {
+        private final PartialInterpretation<A, C> opposite;
+
+        private OppositeInterpretation(ReasoningAdapter adapter, Concreteness concreteness,
+                                                                   PartialSymbol<A, C> partialSymbol, PartialInterpretation<A, C> opposite) {
+                super(adapter, concreteness, partialSymbol);
+                this.opposite = opposite;
+        }
+
+        @Override
+        public A get(Tuple key) {
+                return opposite.get(OppositeUtils.flip(key));
+        }
+
+        @Override
+        public Cursor<Tuple, A> getAll() {
+                return new OppositeCursor<>(opposite.getAll());
+        }
+
+        public static <A1, C1> Factory<A1, C1> of(PartialSymbol<A1, C1> oppositeSymbol) {
+                return (adapter, concreteness, partialSymbol) -> {
+                        var opposite = adapter.getPartialInterpretation(concreteness, oppositeSymbol);
+                        return new OppositeInterpretation<>(adapter, concreteness, partialSymbol, opposite);
+                };
+        }
+
+        private record OppositeCursor<T>(Cursor<Tuple, T> opposite) implements Cursor<Tuple, T> {
+                @Override
+                public Tuple getKey() {
+                        return OppositeUtils.flip(opposite.getKey());
+                }
+
+                @Override
+                public T getValue() {
+                        return opposite.getValue();
+                }
+
+                @Override
+                public boolean isTerminated() {
+                        return opposite.isTerminated();
+                }
+
+                @Override
+                public boolean move() {
+                        return opposite.move();
+                }
+
+                @Override
+                public Set<AnyVersionedMap> getDependingMaps() {
+                        return opposite.getDependingMaps();
+                }
+
+                @Override
+                public boolean isDirty() {
+                        return opposite.isDirty();
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeRefiner.java
new file mode 100644
index 00000000..d09684df
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeRefiner.java
@@ -0,0 +1,32 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.opposite;
+
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.refinement.AbstractPartialInterpretationRefiner;
+import tools.refinery.store.reasoning.refinement.PartialInterpretationRefiner;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.tuple.Tuple;
+
+public class OppositeRefiner<A, C> extends AbstractPartialInterpretationRefiner<A, C> {
+        private final PartialInterpretationRefiner<A, C> opposite;
+
+        protected OppositeRefiner(ReasoningAdapter adapter, PartialSymbol<A, C> partialSymbol,
+                                                          PartialSymbol<A, C> oppositeSymbol) {
+                super(adapter, partialSymbol);
+                opposite = adapter.getRefiner(oppositeSymbol);
+        }
+
+        @Override
+        public boolean merge(Tuple key, A value) {
+                var oppositeKey = OppositeUtils.flip(key);
+                return opposite.merge(oppositeKey, value);
+        }
+
+        public static <A1, C1> Factory<A1, C1> of(PartialSymbol<A1, C1> oppositeSymbol) {
+                return (adapter, partialSymbol) -> new OppositeRefiner<>(adapter, partialSymbol, oppositeSymbol);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeRelationTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeRelationTranslator.java
new file mode 100644
index 00000000..6e15a628
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeRelationTranslator.java
@@ -0,0 +1,62 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.opposite;
+
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.model.ModelStoreConfiguration;
+import tools.refinery.store.query.literal.AbstractCallLiteral;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.reasoning.interpretation.PartialRelationRewriter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.literal.ModalConstraint;
+import tools.refinery.store.reasoning.literal.Modality;
+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.TranslationException;
+
+import java.util.List;
+import java.util.Set;
+
+public class OppositeRelationTranslator implements ModelStoreConfiguration, PartialRelationRewriter {
+        private final PartialRelation linkType;
+        private final PartialRelation opposite;
+
+        public OppositeRelationTranslator(PartialRelation linkType, PartialRelation opposite) {
+                if (linkType.arity() != 2) {
+                        throw new TranslationException(linkType,
+                                        "Expected relation with opposite %s to have arity 2, got %d instead"
+                                                        .formatted(linkType, linkType.arity()));
+                }
+                if (opposite.arity() != 2) {
+                        throw new TranslationException(linkType,
+                                        "Expected opposite %s of %s to have arity 2, got %d instead"
+                                                        .formatted(opposite, linkType, opposite.arity()));
+                }
+                this.linkType = linkType;
+                this.opposite = opposite;
+        }
+
+        @Override
+        public void apply(ModelStoreBuilder storeBuilder) {
+                storeBuilder.with(PartialRelationTranslator.of(linkType)
+                                .rewriter(this)
+                                .interpretation(OppositeInterpretation.of(opposite))
+                                .refiner(OppositeRefiner.of(opposite))
+                                .initializer(new RefinementBasedInitializer<>(linkType)));
+        }
+
+        @Override
+        public List<Literal> rewriteLiteral(Set<Variable> positiveVariables, AbstractCallLiteral literal,
+                                                                                Modality modality, Concreteness concreteness) {
+                var arguments = literal.getArguments();
+                var newArguments = List.of(arguments.get(1), arguments.get(0));
+                var modalOpposite = new ModalConstraint(modality, concreteness, opposite);
+                var oppositeLiteral = literal.withArguments(modalOpposite, newArguments);
+                return List.of(oppositeLiteral);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeUtils.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeUtils.java
new file mode 100644
index 00000000..2a9e6b5d
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/opposite/OppositeUtils.java
@@ -0,0 +1,22 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.opposite;
+
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple2;
+
+final class OppositeUtils {
+        private OppositeUtils() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static Tuple flip(Tuple tuple) {
+                if (!(tuple instanceof Tuple2 tuple2)) {
+                        throw new IllegalArgumentException("Cannot flip tuple: " + tuple);
+                }
+                return Tuple.of(tuple2.value1(), tuple2.value0());
+        }
+}
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
new file mode 100644
index 00000000..b401118e
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/predicate/PredicateTranslator.java
@@ -0,0 +1,93 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.predicate;
+
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.model.ModelStoreConfiguration;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.view.ForbiddenView;
+import tools.refinery.store.query.view.MayView;
+import tools.refinery.store.query.view.MustView;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.reasoning.translator.TranslationException;
+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;
+
+public class PredicateTranslator implements ModelStoreConfiguration {
+        private final PartialRelation relation;
+        private final RelationalQuery query;
+        private final boolean mutable;
+        private final TruthValue defaultValue;
+
+        public PredicateTranslator(PartialRelation relation, RelationalQuery query, boolean mutable,
+                                                           TruthValue defaultValue) {
+                if (relation.arity() != query.arity()) {
+                        throw new TranslationException(relation, "Expected arity %d query for partial relation %s, got %d instead"
+                                        .formatted(relation.arity(), relation, query.arity()));
+                }
+                if (defaultValue.must()) {
+                        throw new TranslationException(relation, "Default value must be UNKNOWN or FALSE");
+                }
+                this.relation = relation;
+                this.query = query;
+                this.mutable = mutable;
+                this.defaultValue = defaultValue;
+        }
+
+        @Override
+        public void apply(ModelStoreBuilder storeBuilder) {
+                var translator = PartialRelationTranslator.of(relation)
+                                .query(query);
+                if (mutable) {
+                        var symbol = Symbol.of(relation.name(), relation.arity(), TruthValue.class, defaultValue);
+                        translator.symbol(symbol);
+
+                        var parameters = new NodeVariable[relation.arity()];
+                        for (int i = 0; i < parameters.length; i++) {
+                                parameters[i] = Variable.of("p" + i);
+                        }
+
+                        var must = Query.builder()
+                                        .parameters(parameters)
+                                        .clause(must(query.call(parameters)))
+                                        .clause(new MustView(symbol).call(parameters))
+                                        .build();
+                        translator.must(must);
+
+                        var mayLiterals = new Literal[2];
+                        mayLiterals[0] = may(query.call(parameters));
+                        if (defaultValue.may()) {
+                                mayLiterals[1] = not(new ForbiddenView(symbol).call(parameters));
+                        } else {
+                                mayLiterals[1] = new MayView(symbol).call(parameters);
+                        }
+                        var may = Query.builder()
+                                        .parameters(parameters)
+                                        .clause(mayLiterals)
+                                        .build();
+                        translator.may(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/proxy/PartialRelationTranslatorProxy.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/proxy/PartialRelationTranslatorProxy.java
new file mode 100644
index 00000000..45dc5bd2
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/proxy/PartialRelationTranslatorProxy.java
@@ -0,0 +1,52 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.proxy;
+
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.model.ModelStoreConfiguration;
+import tools.refinery.store.query.literal.AbstractCallLiteral;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.reasoning.interpretation.PartialRelationRewriter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.literal.ModalConstraint;
+import tools.refinery.store.reasoning.literal.Modality;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+
+import java.util.List;
+import java.util.Set;
+
+public class PartialRelationTranslatorProxy implements ModelStoreConfiguration, PartialRelationRewriter {
+        private final PartialRelation partialRelation;
+        private final PartialRelation targetRelation;
+        private final boolean mutable;
+
+        public PartialRelationTranslatorProxy(PartialRelation partialRelation, PartialRelation targetRelation,
+                                                                                  boolean mutable) {
+                this.partialRelation = partialRelation;
+                this.targetRelation = targetRelation;
+                this.mutable = mutable;
+        }
+
+        @Override
+        public void apply(ModelStoreBuilder storeBuilder) {
+                var translator = PartialRelationTranslator.of(partialRelation)
+                                .interpretation(((adapter, concreteness, partialSymbol) ->
+                                                adapter.getPartialInterpretation(concreteness, targetRelation)))
+                                .rewriter(this);
+                if (mutable) {
+                        translator.refiner((adapter, partialSymbol) -> adapter.getRefiner(targetRelation));
+                }
+                storeBuilder.with(translator);
+        }
+
+        @Override
+        public List<Literal> rewriteLiteral(Set<Variable> positiveVariables, AbstractCallLiteral literal,
+                                                                                Modality modality, Concreteness concreteness) {
+                return List.of(literal.withTarget(ModalConstraint.of(modality, concreteness, targetRelation)));
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/CandidateTypeView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/CandidateTypeView.java
new file mode 100644
index 00000000..faf1b958
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/CandidateTypeView.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+class CandidateTypeView extends InferredTypeView {
+        public CandidateTypeView(Symbol<InferredType> symbol, PartialRelation type) {
+                super(symbol, "candidate", type);
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, InferredType value) {
+                return type.equals(value.candidateType());
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/EliminatedType.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/EliminatedType.java
deleted file mode 100644
index 6e4728db..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/EliminatedType.java
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.translator.typehierarchy;
-
-import tools.refinery.store.reasoning.representation.PartialRelation;
-
-record EliminatedType(PartialRelation replacement) implements TypeAnalysisResult {
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMayTypeView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMayTypeView.java
deleted file mode 100644
index 40de4644..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMayTypeView.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.translator.typehierarchy;
-
-import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.query.view.TuplePreservingView;
-import tools.refinery.store.tuple.Tuple;
-
-import java.util.Objects;
-
-class InferredMayTypeView extends TuplePreservingView<InferredType> {
-        private final PartialRelation type;
-
-        InferredMayTypeView(PartialRelation type) {
-                super(TypeHierarchyTranslationUnit.INFERRED_TYPE_SYMBOL, "%s#may".formatted(type));
-                this.type = type;
-        }
-
-        @Override
-        protected boolean doFilter(Tuple key, InferredType value) {
-                return value.mayConcreteTypes().contains(type);
-        }
-
-        @Override
-        public boolean equals(Object o) {
-                if (this == o) return true;
-                if (o == null || getClass() != o.getClass()) return false;
-                if (!super.equals(o)) return false;
-                InferredMayTypeView that = (InferredMayTypeView) o;
-                return Objects.equals(type, that.type);
-        }
-
-        @Override
-        public int hashCode() {
-                return Objects.hash(super.hashCode(), type);
-        }
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredType.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredType.java
index fd05158b..9a0c2b0f 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredType.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredType.java
@@ -8,21 +8,26 @@ package tools.refinery.store.reasoning.translator.typehierarchy;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 
 import java.util.Collections;
+import java.util.Objects;
 import java.util.Set;
 
-record InferredType(Set<PartialRelation> mustTypes, Set<PartialRelation> mayConcreteTypes,
-                                        PartialRelation currentType) {
+public final class InferredType {
         public static final InferredType UNTYPED = new InferredType(Set.of(), Set.of(), null);
+        private final Set<PartialRelation> mustTypes;
+        private final Set<PartialRelation> mayConcreteTypes;
+        private final PartialRelation candidateType;
+        private final int hashCode;
 
         public InferredType(Set<PartialRelation> mustTypes, Set<PartialRelation> mayConcreteTypes,
-                                                PartialRelation currentType) {
+                                                PartialRelation candidateType) {
                 this.mustTypes = Collections.unmodifiableSet(mustTypes);
                 this.mayConcreteTypes = Collections.unmodifiableSet(mayConcreteTypes);
-                this.currentType = currentType;
+                this.candidateType = candidateType;
+                hashCode = Objects.hash(mustTypes, mayConcreteTypes, candidateType);
         }
 
         public boolean isConsistent() {
-                return currentType != null || mustTypes.isEmpty();
+                return candidateType != null || mustTypes.isEmpty();
         }
 
         public boolean isMust(PartialRelation partialRelation) {
@@ -32,4 +37,40 @@ record InferredType(Set<PartialRelation> mustTypes, Set<PartialRelation> mayConc
         public boolean isMayConcrete(PartialRelation partialRelation) {
                 return mayConcreteTypes.contains(partialRelation);
         }
+
+
+        public Set<PartialRelation> mustTypes() {
+                return mustTypes;
+        }
+
+        public Set<PartialRelation> mayConcreteTypes() {
+                return mayConcreteTypes;
+        }
+
+        public PartialRelation candidateType() {
+                return candidateType;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                InferredType that = (InferredType) o;
+                return Objects.equals(mustTypes, that.mustTypes) &&
+                                Objects.equals(mayConcreteTypes, that.mayConcreteTypes) &&
+                                Objects.equals(candidateType, that.candidateType);
+        }
+
+        @Override
+        public int hashCode() {
+                return hashCode;
+        }
+
+        @Override
+        public String toString() {
+                return "InferredType[" +
+                                "mustTypes=" + mustTypes + ", " +
+                                "mayConcreteTypes=" + mayConcreteTypes + ", " +
+                                "candidateType=" + candidateType + ']';
+        }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredTypeRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredTypeRefiner.java
new file mode 100644
index 00000000..40a7b3fa
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredTypeRefiner.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.translator.typehierarchy;
+
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.refinement.AbstractPartialInterpretationRefiner;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+class InferredTypeRefiner extends AbstractPartialInterpretationRefiner<TruthValue, Boolean> {
+        private final Interpretation<InferredType> interpretation;
+        private final TypeAnalysisResult result;
+
+        private InferredTypeRefiner(ReasoningAdapter adapter, PartialSymbol<TruthValue, Boolean> partialSymbol,
+                                                                Symbol<InferredType> symbol, TypeAnalysisResult result) {
+                super(adapter, partialSymbol);
+                interpretation = adapter.getModel().getInterpretation(symbol);
+                this.result = result;
+        }
+
+        @Override
+        public boolean merge(Tuple key, TruthValue value) {
+                var currentType = interpretation.get(key);
+                var newType = result.merge(currentType, value);
+                interpretation.put(key, newType);
+                return true;
+        }
+
+        public static Factory<TruthValue, Boolean> of(Symbol<InferredType> symbol, TypeAnalysisResult result) {
+                return (adapter, partialSymbol) -> new InferredTypeRefiner(adapter, partialSymbol, symbol, result);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMustTypeView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredTypeView.java
index 1a121547..3c074df5 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMustTypeView.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredTypeView.java
@@ -1,35 +1,30 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.translator.typehierarchy;
 
-import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.query.view.TuplePreservingView;
-import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.Symbol;
 
 import java.util.Objects;
 
-class InferredMustTypeView extends TuplePreservingView<InferredType> {
-        private final PartialRelation type;
+abstract class InferredTypeView extends TuplePreservingView<InferredType> {
+        protected final PartialRelation type;
 
-        InferredMustTypeView(PartialRelation type) {
-                super(TypeHierarchyTranslationUnit.INFERRED_TYPE_SYMBOL, "%s#must".formatted(type));
+        protected InferredTypeView(Symbol<InferredType> symbol, String name, PartialRelation type) {
+                super(symbol, type.name() + "#" + name);
                 this.type = type;
         }
 
         @Override
-        protected boolean doFilter(Tuple key, InferredType value) {
-                return value.mustTypes().contains(type);
-        }
-
-        @Override
         public boolean equals(Object o) {
                 if (this == o) return true;
                 if (o == null || getClass() != o.getClass()) return false;
                 if (!super.equals(o)) return false;
-                InferredMustTypeView that = (InferredMustTypeView) o;
+                InferredTypeView that = (InferredTypeView) o;
                 return Objects.equals(type, that.type);
         }
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/MayTypeView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/MayTypeView.java
new file mode 100644
index 00000000..dcaf61c5
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/MayTypeView.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+class MayTypeView extends InferredTypeView {
+        public MayTypeView(Symbol<InferredType> symbol, PartialRelation type) {
+                super(symbol, "may", type);
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, InferredType value) {
+                return value.mayConcreteTypes().contains(type);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/MustTypeView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/MustTypeView.java
new file mode 100644
index 00000000..833e1594
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/MustTypeView.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+class MustTypeView extends InferredTypeView {
+        public MustTypeView(Symbol<InferredType> symbol, PartialRelation type) {
+                super(symbol, "must", type);
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, InferredType value) {
+                return value.mustTypes().contains(type);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/PreservedType.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/PreservedType.java
deleted file mode 100644
index 0696f4c3..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/PreservedType.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.translator.typehierarchy;
-
-import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.representation.TruthValue;
-
-import java.util.*;
-
-final class PreservedType implements TypeAnalysisResult {
-        private final ExtendedTypeInfo extendedTypeInfo;
-        private final List<PartialRelation> directSubtypes;
-        private final List<ExtendedTypeInfo> allExternalTypeInfoList;
-        private final InferredType inferredType;
-
-        public PreservedType(ExtendedTypeInfo extendedTypeInfo, List<ExtendedTypeInfo> allExternalTypeInfoList) {
-                this.extendedTypeInfo = extendedTypeInfo;
-                directSubtypes = List.copyOf(extendedTypeInfo.getDirectSubtypes());
-                this.allExternalTypeInfoList = allExternalTypeInfoList;
-                inferredType = propagateMust(extendedTypeInfo.getAllSupertypesAndSelf(),
-                                extendedTypeInfo.getConcreteSubtypesAndSelf());
-        }
-
-        public PartialRelation type() {
-                return extendedTypeInfo.getType();
-        }
-
-        public List<PartialRelation> getDirectSubtypes() {
-                return directSubtypes;
-        }
-
-        public boolean isAbstractType() {
-                return extendedTypeInfo.isAbstractType();
-        }
-
-        public boolean isVacuous() {
-                return isAbstractType() && directSubtypes.isEmpty();
-        }
-
-        public InferredType asInferredType() {
-                return inferredType;
-        }
-
-        public InferredType merge(InferredType inferredType, TruthValue value) {
-                return switch (value) {
-                        case UNKNOWN -> inferredType;
-                        case TRUE -> addMust(inferredType);
-                        case FALSE -> removeMay(inferredType);
-                        case ERROR -> addError(inferredType);
-                };
-        }
-
-        private InferredType addMust(InferredType inferredType) {
-                var originalMustTypes = inferredType.mustTypes();
-                if (originalMustTypes.contains(type())) {
-                        return inferredType;
-                }
-                var mustTypes = new HashSet<>(originalMustTypes);
-                extendedTypeInfo.addMust(mustTypes);
-                var originalMayConcreteTypes = inferredType.mayConcreteTypes();
-                var mayConcreteTypes = new LinkedHashSet<>(originalMayConcreteTypes);
-                Set<PartialRelation> mayConcreteTypesResult;
-                if (mayConcreteTypes.retainAll(extendedTypeInfo.getConcreteSubtypesAndSelf())) {
-                        mayConcreteTypesResult = mayConcreteTypes;
-                } else {
-                        mayConcreteTypesResult = originalMayConcreteTypes;
-                }
-                return propagateMust(mustTypes, mayConcreteTypesResult);
-        }
-
-        private InferredType removeMay(InferredType inferredType) {
-                var originalMayConcreteTypes = inferredType.mayConcreteTypes();
-                var mayConcreteTypes = new LinkedHashSet<>(originalMayConcreteTypes);
-                if (!mayConcreteTypes.removeAll(extendedTypeInfo.getConcreteSubtypesAndSelf())) {
-                        return inferredType;
-                }
-                return propagateMust(inferredType.mustTypes(), mayConcreteTypes);
-        }
-
-        private InferredType addError(InferredType inferredType) {
-                var originalMustTypes = inferredType.mustTypes();
-                if (originalMustTypes.contains(type())) {
-                        if (inferredType.mayConcreteTypes().isEmpty()) {
-                                return inferredType;
-                        }
-                        return new InferredType(originalMustTypes, Set.of(), null);
-                }
-                var mustTypes = new HashSet<>(originalMustTypes);
-                extendedTypeInfo.addMust(mustTypes);
-                return new InferredType(mustTypes, Set.of(), null);
-        }
-
-        private InferredType propagateMust(Set<PartialRelation> originalMustTypes,
-                                                                           Set<PartialRelation> mayConcreteTypes) {
-                // It is possible that there is not type at all, do not force one by propagation.
-                var maybeUntyped = originalMustTypes.isEmpty();
-                // Para-consistent case, do not propagate must types to avoid logical explosion.
-                var paraConsistentOrSurelyUntyped = mayConcreteTypes.isEmpty();
-                if (maybeUntyped || paraConsistentOrSurelyUntyped) {
-                        return new InferredType(originalMustTypes, mayConcreteTypes, null);
-                }
-                var currentType = computeCurrentType(mayConcreteTypes);
-                var mustTypes = new HashSet<>(originalMustTypes);
-                boolean changed = false;
-                for (var newMustExtendedTypeInfo : allExternalTypeInfoList) {
-                        var newMustType = newMustExtendedTypeInfo.getType();
-                        if (mustTypes.contains(newMustType)) {
-                                continue;
-                        }
-                        if (newMustExtendedTypeInfo.allowsAllConcreteTypes(mayConcreteTypes)) {
-                                newMustExtendedTypeInfo.addMust(mustTypes);
-                                changed = true;
-                        }
-                }
-                if (!changed) {
-                        return new InferredType(originalMustTypes, mayConcreteTypes, currentType);
-                }
-                return new InferredType(mustTypes, mayConcreteTypes, currentType);
-        }
-
-        /**
-         * Returns a concrete type that is allowed by a (consistent, i.e., nonempty) set of <b>may</b> concrete types.
-         *
-         * @param mayConcreteTypes The set of allowed concrete types. Must not be empty.
-         * @return The first concrete type that is allowed by {@code matConcreteTypes}.
-         */
-        private PartialRelation computeCurrentType(Set<PartialRelation> mayConcreteTypes) {
-                for (var concreteExtendedTypeInfo : allExternalTypeInfoList) {
-                        var concreteType = concreteExtendedTypeInfo.getType();
-                        if (!concreteExtendedTypeInfo.isAbstractType() && mayConcreteTypes.contains(concreteType)) {
-                                return concreteType;
-                        }
-                }
-                // We have already filtered out the para-consistent case in {@link #propagateMust(Set<PartialRelation>,
-                // Set<PartialRelation>}.
-                throw new AssertionError("No concrete type in %s".formatted(mayConcreteTypes));
-        }
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalysisResult.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalysisResult.java
index fbf8a7c9..ebe0d1b9 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalysisResult.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalysisResult.java
@@ -5,5 +5,141 @@
  */
 package tools.refinery.store.reasoning.translator.typehierarchy;
 
-sealed interface TypeAnalysisResult permits EliminatedType, PreservedType {
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.TruthValue;
+
+import java.util.*;
+
+public final class TypeAnalysisResult {
+        private final ExtendedTypeInfo extendedTypeInfo;
+        private final List<PartialRelation> directSubtypes;
+        private final List<ExtendedTypeInfo> allExternalTypeInfoList;
+        private final InferredType inferredType;
+
+        public TypeAnalysisResult(ExtendedTypeInfo extendedTypeInfo, List<ExtendedTypeInfo> allExternalTypeInfoList) {
+                this.extendedTypeInfo = extendedTypeInfo;
+                directSubtypes = List.copyOf(extendedTypeInfo.getDirectSubtypes());
+                this.allExternalTypeInfoList = allExternalTypeInfoList;
+                inferredType = propagateMust(extendedTypeInfo.getAllSupertypesAndSelf(),
+                                extendedTypeInfo.getConcreteSubtypesAndSelf());
+        }
+
+        public PartialRelation type() {
+                return extendedTypeInfo.getType();
+        }
+
+        public List<PartialRelation> getDirectSubtypes() {
+                return directSubtypes;
+        }
+
+        public boolean isAbstractType() {
+                return extendedTypeInfo.isAbstractType();
+        }
+
+        public boolean isVacuous() {
+                return isAbstractType() && directSubtypes.isEmpty();
+        }
+
+        public InferredType asInferredType() {
+                return inferredType;
+        }
+
+        public boolean isSubtypeOf(TypeAnalysisResult other) {
+                return extendedTypeInfo.getAllSubtypes().contains(other.type());
+        }
+
+        public InferredType merge(InferredType inferredType, TruthValue value) {
+                return switch (value) {
+                        case UNKNOWN -> inferredType;
+                        case TRUE -> addMust(inferredType);
+                        case FALSE -> removeMay(inferredType);
+                        case ERROR -> addError(inferredType);
+                };
+        }
+
+        private InferredType addMust(InferredType inferredType) {
+                var originalMustTypes = inferredType.mustTypes();
+                if (originalMustTypes.contains(type())) {
+                        return inferredType;
+                }
+                var mustTypes = new HashSet<>(originalMustTypes);
+                extendedTypeInfo.addMust(mustTypes);
+                var originalMayConcreteTypes = inferredType.mayConcreteTypes();
+                var mayConcreteTypes = new LinkedHashSet<>(originalMayConcreteTypes);
+                Set<PartialRelation> mayConcreteTypesResult;
+                if (mayConcreteTypes.retainAll(extendedTypeInfo.getConcreteSubtypesAndSelf())) {
+                        mayConcreteTypesResult = mayConcreteTypes;
+                } else {
+                        mayConcreteTypesResult = originalMayConcreteTypes;
+                }
+                return propagateMust(mustTypes, mayConcreteTypesResult);
+        }
+
+        private InferredType removeMay(InferredType inferredType) {
+                var originalMayConcreteTypes = inferredType.mayConcreteTypes();
+                var mayConcreteTypes = new LinkedHashSet<>(originalMayConcreteTypes);
+                if (!mayConcreteTypes.removeAll(extendedTypeInfo.getConcreteSubtypesAndSelf())) {
+                        return inferredType;
+                }
+                return propagateMust(inferredType.mustTypes(), mayConcreteTypes);
+        }
+
+        private InferredType addError(InferredType inferredType) {
+                var originalMustTypes = inferredType.mustTypes();
+                if (originalMustTypes.contains(type())) {
+                        if (inferredType.mayConcreteTypes().isEmpty()) {
+                                return inferredType;
+                        }
+                        return new InferredType(originalMustTypes, Set.of(), null);
+                }
+                var mustTypes = new HashSet<>(originalMustTypes);
+                extendedTypeInfo.addMust(mustTypes);
+                return new InferredType(mustTypes, Set.of(), null);
+        }
+
+        private InferredType propagateMust(Set<PartialRelation> originalMustTypes,
+                                                                           Set<PartialRelation> mayConcreteTypes) {
+                // It is possible that there is not type at all, do not force one by propagation.
+                var maybeUntyped = originalMustTypes.isEmpty();
+                // Para-consistent case, do not propagate must types to avoid logical explosion.
+                var paraConsistentOrSurelyUntyped = mayConcreteTypes.isEmpty();
+                if (maybeUntyped || paraConsistentOrSurelyUntyped) {
+                        return new InferredType(originalMustTypes, mayConcreteTypes, null);
+                }
+                var currentType = computeCurrentType(mayConcreteTypes);
+                var mustTypes = new HashSet<>(originalMustTypes);
+                boolean changed = false;
+                for (var newMustExtendedTypeInfo : allExternalTypeInfoList) {
+                        var newMustType = newMustExtendedTypeInfo.getType();
+                        if (mustTypes.contains(newMustType)) {
+                                continue;
+                        }
+                        if (newMustExtendedTypeInfo.allowsAllConcreteTypes(mayConcreteTypes)) {
+                                newMustExtendedTypeInfo.addMust(mustTypes);
+                                changed = true;
+                        }
+                }
+                if (!changed) {
+                        return new InferredType(originalMustTypes, mayConcreteTypes, currentType);
+                }
+                return new InferredType(mustTypes, mayConcreteTypes, currentType);
+        }
+
+        /**
+         * Returns a concrete type that is allowed by a (consistent, i.e., nonempty) set of <b>may</b> concrete types.
+         *
+         * @param mayConcreteTypes The set of allowed concrete types. Must not be empty.
+         * @return The first concrete type that is allowed by {@code matConcreteTypes}.
+         */
+        private PartialRelation computeCurrentType(Set<PartialRelation> mayConcreteTypes) {
+                for (var concreteExtendedTypeInfo : allExternalTypeInfoList) {
+                        var concreteType = concreteExtendedTypeInfo.getType();
+                        if (!concreteExtendedTypeInfo.isAbstractType() && mayConcreteTypes.contains(concreteType)) {
+                                return concreteType;
+                        }
+                }
+                // We have already filtered out the para-consistent case in {@link #propagateMust(Set<PartialRelation>,
+                // Set<PartialRelation>}.
+                throw new AssertionError("No concrete type in %s".formatted(mayConcreteTypes));
+        }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzer.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchy.java
index e97ce954..3f918c97 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzer.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchy.java
@@ -6,17 +6,20 @@
 package tools.refinery.store.reasoning.translator.typehierarchy;
 
 import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
 
 import java.util.*;
 
-class TypeAnalyzer {
+public class TypeHierarchy {
+        private final Set<PartialRelation> allTypes;
         private final Map<PartialRelation, ExtendedTypeInfo> extendedTypeInfoMap;
         private final Map<PartialRelation, PartialRelation> replacements = new LinkedHashMap<>();
         private final InferredType unknownType;
-        private final Map<PartialRelation, TypeAnalysisResult> analysisResults;
+        private final Map<PartialRelation, TypeAnalysisResult> preservedTypes;
 
-        public TypeAnalyzer(Map<PartialRelation, TypeInfo> typeInfoMap) {
+        TypeHierarchy(Map<PartialRelation, TypeInfo> typeInfoMap) {
                 int size = typeInfoMap.size();
+                allTypes = Collections.unmodifiableSet(new LinkedHashSet<>(typeInfoMap.keySet()));
                 extendedTypeInfoMap = new LinkedHashMap<>(size);
                 var concreteTypes = new LinkedHashSet<PartialRelation>();
                 int index = 0;
@@ -34,15 +37,39 @@ class TypeAnalyzer {
                 computeAllAndConcreteSubtypes();
                 computeDirectSubtypes();
                 eliminateTrivialSupertypes();
-                analysisResults = computeAnalysisResults();
+                preservedTypes = computeAnalysisResults();
+        }
+
+        public boolean isEmpty() {
+                return extendedTypeInfoMap.isEmpty();
         }
 
         public InferredType getUnknownType() {
                 return unknownType;
         }
 
-        public Map<PartialRelation, TypeAnalysisResult> getAnalysisResults() {
-                return analysisResults;
+        public Set<PartialRelation> getAllTypes() {
+                return allTypes;
+        }
+
+        public Map<PartialRelation, TypeAnalysisResult> getPreservedTypes() {
+                return preservedTypes;
+        }
+
+        public Map<PartialRelation, PartialRelation> getEliminatedTypes() {
+                return Collections.unmodifiableMap(replacements);
+        }
+
+        public TypeAnalysisResult getAnalysisResult(PartialRelation type) {
+                var preservedResult = preservedTypes.get(type);
+                if (preservedResult != null) {
+                        return preservedResult;
+                }
+                var eliminatedResult = replacements.get(type);
+                if (eliminatedResult != null) {
+                        return preservedTypes.get(eliminatedResult);
+                }
+                throw new IllegalArgumentException("Unknown type: " + type);
         }
 
         private void computeAllSupertypes() {
@@ -53,7 +80,13 @@ class TypeAnalyzer {
                                 var found = new HashSet<PartialRelation>();
                                 var allSupertypes = extendedTypeInfo.getAllSupertypes();
                                 for (var supertype : allSupertypes) {
-                                        found.addAll(extendedTypeInfoMap.get(supertype).getAllSupertypes());
+                                        var supertypeInfo = extendedTypeInfoMap.get(supertype);
+                                        if (supertypeInfo == null) {
+                                                throw new TranslationException(extendedTypeInfo.getType(),
+                                                                "Supertype %s of %s is missing from the type hierarchy"
+                                                                                .formatted(supertype, extendedTypeInfo.getType()));
+                                        }
+                                        found.addAll(supertypeInfo.getAllSupertypes());
                                 }
                                 if (allSupertypes.addAll(found)) {
                                         changed = true;
@@ -70,7 +103,7 @@ class TypeAnalyzer {
                         }
                         for (var supertype : extendedTypeInfo.getAllSupertypes()) {
                                 if (type.equals(supertype)) {
-                                        throw new IllegalArgumentException("%s cannot be a supertype of itself".formatted(type));
+                                        throw new TranslationException(type, "%s cannot be a supertype of itself".formatted(type));
                                 }
                                 var supertypeInfo = extendedTypeInfoMap.get(supertype);
                                 supertypeInfo.getAllSubtypes().add(type);
@@ -95,25 +128,37 @@ class TypeAnalyzer {
         }
 
         private void eliminateTrivialSupertypes() {
-                boolean changed;
-                do {
+                Set<PartialRelation> toInspect = new HashSet<>(extendedTypeInfoMap.keySet());
+                while (!toInspect.isEmpty()) {
                         var toRemove = new ArrayList<PartialRelation>();
-                        for (var entry : extendedTypeInfoMap.entrySet()) {
-                                var extendedTypeInfo = entry.getValue();
-                                boolean isAbstract = extendedTypeInfo.isAbstractType();
-                                // Do not eliminate abstract types with 0 subtypes, because they can be used para-consistently, i.e.,
-                                // an object determined to <b>must</b> have an abstract type with 0 subtypes <b>may not</b> ever exist.
-                                boolean hasSingleDirectSubtype = extendedTypeInfo.getDirectSubtypes().size() == 1;
-                                if (isAbstract && hasSingleDirectSubtype) {
-                                        toRemove.add(entry.getKey());
+                        for (var partialRelation : toInspect) {
+                                var extendedTypeInfo = extendedTypeInfoMap.get(partialRelation);
+                                if (extendedTypeInfo != null && isTrivialSupertype(extendedTypeInfo)) {
+                                        toRemove.add(partialRelation);
                                 }
                         }
-                        toRemove.forEach(this::removeTrivialType);
-                        changed = !toRemove.isEmpty();
-                } while (changed);
+                        toInspect.clear();
+                        for (var partialRelation : toRemove) {
+                                removeTrivialType(partialRelation, toInspect);
+                        }
+                }
+        }
+
+        private boolean isTrivialSupertype(ExtendedTypeInfo extendedTypeInfo) {
+                if (!extendedTypeInfo.isAbstractType()) {
+                        return false;
+                }
+                var subtypeIterator = extendedTypeInfo.getDirectSubtypes().iterator();
+                if (!subtypeIterator.hasNext()) {
+                        // Do not eliminate abstract types with 0 subtypes, because they can be used para-consistently, i.e.,
+                        // an object determined to <b>must</b> have an abstract type with 0 subtypes <b>may not</b> ever exist.
+                        return false;
+                }
+                var directSubtype = subtypeIterator.next();
+                return !extendedTypeInfoMap.get(directSubtype).isAbstractType() && !subtypeIterator.hasNext();
         }
 
-        private void removeTrivialType(PartialRelation trivialType) {
+        private void removeTrivialType(PartialRelation trivialType, Set<PartialRelation> toInspect) {
                 var extendedTypeInfo = extendedTypeInfoMap.get(trivialType);
                 var iterator = extendedTypeInfo.getDirectSubtypes().iterator();
                 if (!iterator.hasNext()) {
@@ -125,7 +170,6 @@ class TypeAnalyzer {
                         throw new AssertionError("Expected trivial supertype %s to have at most 1 direct subtype"
                                         .formatted(trivialType));
                 }
-                replacements.put(trivialType, replacement);
                 for (var supertype : extendedTypeInfo.getAllSupertypes()) {
                         var extendedSupertypeInfo = extendedTypeInfoMap.get(supertype);
                         if (!extendedSupertypeInfo.getAllSubtypes().remove(trivialType)) {
@@ -134,6 +178,9 @@ class TypeAnalyzer {
                         var directSubtypes = extendedSupertypeInfo.getDirectSubtypes();
                         if (directSubtypes.remove(trivialType)) {
                                 directSubtypes.add(replacement);
+                                if (extendedSupertypeInfo.isAbstractType() && directSubtypes.size() == 1) {
+                                        toInspect.add(supertype);
+                                }
                         }
                 }
                 for (var subtype : extendedTypeInfo.getAllSubtypes()) {
@@ -156,17 +203,13 @@ class TypeAnalyzer {
 
         private Map<PartialRelation, TypeAnalysisResult> computeAnalysisResults() {
                 var allExtendedTypeInfoList = sortTypes();
-                var results = new LinkedHashMap<PartialRelation, TypeAnalysisResult>(
-                                allExtendedTypeInfoList.size() + replacements.size());
+                var preservedResults = new LinkedHashMap<PartialRelation, TypeAnalysisResult>(
+                                allExtendedTypeInfoList.size());
                 for (var extendedTypeInfo : allExtendedTypeInfoList) {
                         var type = extendedTypeInfo.getType();
-                        results.put(type, new PreservedType(extendedTypeInfo, allExtendedTypeInfoList));
-                }
-                for (var entry : replacements.entrySet()) {
-                        var type = entry.getKey();
-                        results.put(type, new EliminatedType(entry.getValue()));
+                        preservedResults.put(type, new TypeAnalysisResult(extendedTypeInfo, allExtendedTypeInfoList));
                 }
-                return Collections.unmodifiableMap(results);
+                return Collections.unmodifiableMap(preservedResults);
         }
 
         private List<ExtendedTypeInfo> sortTypes() {
@@ -204,4 +247,8 @@ class TypeAnalyzer {
                 }
                 return Collections.unmodifiableList(sorted);
         }
+
+        public static TypeHierarchyBuilder builder() {
+                return new TypeHierarchyBuilder();
+        }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyBuilder.java
new file mode 100644
index 00000000..ce8fda05
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyBuilder.java
@@ -0,0 +1,66 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslationException;
+
+import java.util.*;
+
+@SuppressWarnings("UnusedReturnValue")
+public class TypeHierarchyBuilder {
+        protected final Map<PartialRelation, TypeInfo> typeInfoMap = new LinkedHashMap<>();
+
+        protected TypeHierarchyBuilder() {
+        }
+
+        public TypeHierarchyBuilder type(PartialRelation partialRelation, TypeInfo typeInfo) {
+                if (partialRelation.arity() != 1) {
+                        throw new TranslationException(partialRelation,
+                                        "Only types of arity 1 are supported, got %s with %d instead"
+                                                        .formatted(partialRelation, partialRelation.arity()));
+                }
+                var putResult = typeInfoMap.put(partialRelation, typeInfo);
+                if (putResult != null && !putResult.equals(typeInfo)) {
+                        throw new TranslationException(partialRelation,
+                                        "Duplicate type info for partial relation: " + partialRelation);
+                }
+                return this;
+        }
+
+        public TypeHierarchyBuilder type(PartialRelation partialRelation, boolean abstractType,
+                                                                         PartialRelation... supertypes) {
+                return type(partialRelation, abstractType, Set.of(supertypes));
+        }
+
+        public TypeHierarchyBuilder type(PartialRelation partialRelation, boolean abstractType,
+                                                                         Collection<PartialRelation> supertypes) {
+                return type(partialRelation, new TypeInfo(supertypes, abstractType));
+        }
+
+        public TypeHierarchyBuilder type(PartialRelation partialRelation, PartialRelation... supertypes) {
+                return type(partialRelation, List.of(supertypes));
+        }
+
+        public TypeHierarchyBuilder type(PartialRelation partialRelation, Collection<PartialRelation> supertypes) {
+                return type(partialRelation, false, supertypes);
+        }
+
+        public TypeHierarchyBuilder types(Collection<Map.Entry<PartialRelation, TypeInfo>> entries) {
+                for (var entry : entries) {
+                        type(entry.getKey(), entry.getValue());
+                }
+                return this;
+        }
+
+        public TypeHierarchyBuilder types(Map<PartialRelation, TypeInfo> map) {
+                return types(map.entrySet());
+        }
+
+        public TypeHierarchy build() {
+                return new TypeHierarchy(typeInfoMap);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyInitializer.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyInitializer.java
new file mode 100644
index 00000000..233e43f0
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyInitializer.java
@@ -0,0 +1,64 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.function.Function;
+
+public class TypeHierarchyInitializer implements PartialModelInitializer {
+        private final TypeHierarchy typeHierarchy;
+        private final Symbol<InferredType> typeSymbol;
+
+        public TypeHierarchyInitializer(TypeHierarchy typeHierarchy, Symbol<InferredType> typeSymbol) {
+                this.typeHierarchy = typeHierarchy;
+                this.typeSymbol = typeSymbol;
+        }
+
+        @Override
+        public void initialize(Model model, ModelSeed modelSeed) {
+                var inferredTypes = new InferredType[modelSeed.getNodeCount()];
+                Arrays.fill(inferredTypes, typeHierarchy.getUnknownType());
+                for (var type : typeHierarchy.getAllTypes()) {
+                        model.checkCancelled();
+                        initializeType(type, inferredTypes, model, modelSeed);
+                }
+                var typeInterpretation = model.getInterpretation(typeSymbol);
+                var uniqueTable = new HashMap<InferredType, InferredType>();
+                for (int i = 0; i < inferredTypes.length; i++) {
+                        model.checkCancelled();
+                        var uniqueType = uniqueTable.computeIfAbsent(inferredTypes[i], Function.identity());
+                        typeInterpretation.put(Tuple.of(i), uniqueType);
+                }
+        }
+
+        private void initializeType(PartialRelation type, InferredType[] inferredTypes, Model model, ModelSeed modelSeed) {
+                var cursor = modelSeed.getCursor(type, TruthValue.UNKNOWN);
+                var analysisResult = typeHierarchy.getAnalysisResult(type);
+                while (cursor.move()) {
+                        model.checkCancelled();
+                        var i = cursor.getKey().get(0);
+                        checkNodeId(inferredTypes, i);
+                        var value = cursor.getValue();
+                        inferredTypes[i] = analysisResult.merge(inferredTypes[i], value);
+                }
+        }
+
+        private void checkNodeId(InferredType[] inferredTypes, int nodeId) {
+                if (nodeId < 0 || nodeId >= inferredTypes.length) {
+                        throw new IllegalArgumentException("Expected node id %d to be lower than model size %d"
+                                        .formatted(nodeId, inferredTypes.length));
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslationUnit.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslationUnit.java
deleted file mode 100644
index 06e3c05f..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslationUnit.java
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.translator.typehierarchy;
-
-import tools.refinery.store.model.Model;
-import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.reasoning.translator.TranslatedRelation;
-import tools.refinery.store.reasoning.translator.TranslationUnit;
-import tools.refinery.store.representation.Symbol;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
-public class TypeHierarchyTranslationUnit extends TranslationUnit {
-        static final Symbol<InferredType> INFERRED_TYPE_SYMBOL = Symbol.of(
-                        "inferredType", 1, InferredType.class, InferredType.UNTYPED);
-
-        private final TypeAnalyzer typeAnalyzer;
-
-        public TypeHierarchyTranslationUnit(Map<PartialRelation, TypeInfo> typeInfoMap) {
-                typeAnalyzer = new TypeAnalyzer(typeInfoMap);
-        }
-
-        @Override
-        public Collection<TranslatedRelation> getTranslatedRelations() {
-                return List.of();
-        }
-
-        @Override
-        public void initializeModel(Model model, int nodeCount) {
-
-        }
-}
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
new file mode 100644
index 00000000..37ea1448
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslator.java
@@ -0,0 +1,111 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+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 {
+        public static final Symbol<InferredType> TYPE_SYMBOL = Symbol.of("TYPE", 1, InferredType.class,
+                        InferredType.UNTYPED);
+        private final TypeHierarchy typeHierarchy;
+
+        public TypeHierarchyTranslator(TypeHierarchy typeHierarchy) {
+                this.typeHierarchy = typeHierarchy;
+        }
+
+        @Override
+        public void apply(ModelStoreBuilder storeBuilder) {
+                if (typeHierarchy.isEmpty()) {
+                        return;
+                }
+
+                storeBuilder.symbol(TYPE_SYMBOL);
+
+                for (var entry : typeHierarchy.getPreservedTypes().entrySet()) {
+                        storeBuilder.with(createPreservedTypeTranslator(entry.getKey(), entry.getValue()));
+                }
+
+                for (var entry : typeHierarchy.getEliminatedTypes().entrySet()) {
+                        storeBuilder.with(createEliminatedTypeTranslator(entry.getKey(), entry.getValue()));
+                }
+
+                var reasoningBuilder = storeBuilder.getAdapter(ReasoningBuilder.class);
+                reasoningBuilder.initializer(new TypeHierarchyInitializer(typeHierarchy, TYPE_SYMBOL));
+        }
+
+        private ModelStoreConfiguration createPreservedTypeTranslator(PartialRelation type, TypeAnalysisResult result) {
+                var may = Query.of(type.name() + "#partial#may", (builder, p1) -> {
+                        if (!result.isAbstractType()) {
+                                builder.clause(new MayTypeView(TYPE_SYMBOL, type).call(p1));
+                        }
+                        for (var subtype : result.getDirectSubtypes()) {
+                                builder.clause(may(subtype.call(p1)));
+                        }
+                });
+
+                var must = Query.of(type.name() + "#partial#must", (builder, p1) -> builder.clause(
+                                new MustTypeView(TYPE_SYMBOL, type).call(p1)
+                ));
+
+                var candidate = Query.of(type.name() + "#candidate", (builder, p1) -> {
+                        if (!result.isAbstractType()) {
+                                builder.clause(new CandidateTypeView(TYPE_SYMBOL, type).call(p1));
+                        }
+                        for (var subtype : result.getDirectSubtypes()) {
+                                builder.clause(PartialLiterals.candidateMust(subtype.call(p1)));
+                        }
+                });
+
+                var translator = PartialRelationTranslator.of(type)
+                                .may(may)
+                                .must(must)
+                                .candidate(candidate)
+                                .refiner(InferredTypeRefiner.of(TYPE_SYMBOL, 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(
+                        PartialRelation type, PartialRelation replacement) {
+                return new PartialRelationTranslatorProxy(type, replacement, true);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeInfo.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeInfo.java
index 9f897e46..e6bdaff2 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeInfo.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeInfo.java
@@ -9,43 +9,15 @@ import tools.refinery.store.reasoning.representation.PartialRelation;
 
 import java.util.*;
 
-public record TypeInfo(Collection<PartialRelation> supertypes, boolean abstractType) {
-        public static Builder builder() {
-                return new Builder();
+public record TypeInfo(Set<PartialRelation> supertypes, boolean abstractType) {
+        public TypeInfo(Collection<PartialRelation> supertypes, boolean abstractType) {
+                this(Set.copyOf(supertypes), abstractType);
         }
 
-        public static class Builder {
-                private final Set<PartialRelation> supertypes = new LinkedHashSet<>();
-                private boolean abstractType;
-
-                private Builder() {
-                }
-
-                public Builder supertypes(Collection<PartialRelation> supertypes) {
-                        this.supertypes.addAll(supertypes);
-                        return this;
-                }
-
-                public Builder supertypes(PartialRelation... supertypes) {
-                        return supertypes(List.of(supertypes));
-                }
-
-                public Builder supertype(PartialRelation supertype) {
-                        supertypes.add(supertype);
-                        return this;
-                }
-
-                public Builder abstractType(boolean abstractType) {
-                        this.abstractType = abstractType;
-                        return this;
-                }
-
-                public Builder abstractType() {
-                        return abstractType(true);
-                }
-
-                public TypeInfo build() {
-                        return new TypeInfo(Collections.unmodifiableSet(supertypes), abstractType);
-                }
+        public TypeInfo addSupertype(PartialRelation newSupertype) {
+                var newSupertypes = new ArrayList<PartialRelation>(supertypes.size() + 1);
+                newSupertypes.addAll(supertypes);
+                newSupertypes.add(newSupertype);
+                return new TypeInfo(newSupertypes, abstractType);
         }
 }