feat: multi-object based EQUALS and EXISTS

Adds translator for EQUALS and EXISTS symbols based on the multi-object
formalism. Only diagonal equality links are supported (e.g., distinct nodes may
not be EQUALS with each other).

Also introduces initial model seeds to separate partial interpreter construction
and graph initialization better.

29 files changed, 872 insertions, 226 deletions

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 6d416436..f560c74c 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
@@ -8,7 +8,9 @@ package tools.refinery.store.reasoning;
 import tools.refinery.store.adapter.ModelAdapterBuilder;
 import tools.refinery.store.model.ModelStore;
 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;
@@ -18,8 +20,6 @@ import tools.refinery.store.representation.Symbol;
 
 @SuppressWarnings("UnusedReturnValue")
 public interface ReasoningBuilder extends ModelAdapterBuilder {
-        ReasoningBuilder initialNodeCount(int nodeCount);
-
         ReasoningBuilder partialSymbol(AnyPartialSymbolTranslator translator);
 
         <T> ReasoningBuilder storageRefiner(Symbol<T> symbol, StorageRefiner.Factory<T> refiner);
@@ -28,6 +28,10 @@ public interface ReasoningBuilder extends ModelAdapterBuilder {
 
         <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, Concreteness concreteness, Dnf dnf);
 
         @Override
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 fae60d9e..6f9354eb 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
@@ -8,6 +8,7 @@ package tools.refinery.store.reasoning;
 import tools.refinery.store.adapter.ModelStoreAdapter;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+import tools.refinery.store.reasoning.seed.ModelSeed;
 
 import java.util.Collection;
 
@@ -16,7 +17,7 @@ public interface ReasoningStoreAdapter extends ModelStoreAdapter {
 
         Collection<AnyPartialSymbol> getRefinablePartialSymbols();
 
-        Model createInitialModel();
+        Model createInitialModel(ModelSeed modelSeed);
 
         @Override
         ReasoningAdapter createModelAdapter(Model model);
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..bc379c64
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/PartialClauseRewriter.java
@@ -0,0 +1,91 @@
+/*
+ * 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.dnf.DnfClause;
+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.ModalConstraint;
+import tools.refinery.store.reasoning.literal.Modality;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+
+import java.util.*;
+
+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;
+                }
+                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 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);
+                completedLiterals.add(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));
+                }
+        }
+}
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
index 132022d1..79cba263 100644
--- 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
@@ -6,18 +6,13 @@
 package tools.refinery.store.reasoning.internal;
 
 import tools.refinery.store.query.dnf.Dnf;
-import tools.refinery.store.query.dnf.DnfClause;
-import tools.refinery.store.query.literal.AbstractCallLiteral;
-import tools.refinery.store.query.literal.Literal;
 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.literal.Concreteness;
-import tools.refinery.store.reasoning.literal.ModalConstraint;
-import tools.refinery.store.reasoning.literal.Modality;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 
-import java.util.*;
+import java.util.HashMap;
+import java.util.Map;
 
 class PartialQueryRewriter extends AbstractRecursiveRewriter {
         private final DnfLifter lifter;
@@ -27,6 +22,18 @@ class PartialQueryRewriter extends AbstractRecursiveRewriter {
                 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);
@@ -37,67 +44,10 @@ class PartialQueryRewriter extends AbstractRecursiveRewriter {
         protected Dnf doRewrite(Dnf dnf) {
                 var builder = Dnf.builderFrom(dnf);
                 for (var clause : dnf.getClauses()) {
-                        builder.clause(rewriteClause(clause));
+                        var clauseRewriter = new PartialClauseRewriter(this);
+                        var rewrittenClauses = clauseRewriter.rewriteClause(clause);
+                        builder.clause(rewrittenClauses);
                 }
                 return builder.build();
         }
-
-        private List<Literal> rewriteClause(DnfClause clause) {
-                var completedLiterals = new ArrayList<Literal>();
-                var workList = new ArrayDeque<>(clause.literals());
-                while (!workList.isEmpty()) {
-                        var literal = workList.removeFirst();
-                        rewrite(literal, completedLiterals, workList);
-                }
-                return completedLiterals;
-        }
-
-        private void rewrite(Literal literal, List<Literal> completedLiterals, Deque<Literal> workList) {
-                if (!(literal instanceof AbstractCallLiteral callLiteral)) {
-                        completedLiterals.add(literal);
-                        return;
-                }
-                var target = callLiteral.getTarget();
-                if (target instanceof Dnf dnf) {
-                        rewriteRecursively(callLiteral, dnf, completedLiterals);
-                } 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, completedLiterals);
-                        } else if (constraint instanceof PartialRelation partialRelation) {
-                                rewrite(callLiteral, modality, concreteness, partialRelation, workList);
-                        } else {
-                                throw new IllegalArgumentException("Cannot interpret modal constraint: " + modalConstraint);
-                        }
-                } else {
-                        completedLiterals.add(literal);
-                }
-        }
-
-        private void rewriteRecursively(AbstractCallLiteral callLiteral, Modality modality, Concreteness concreteness,
-                                                                        Dnf dnf, List<Literal> completedLiterals) {
-                var liftedDnf = lifter.lift(modality, concreteness, dnf);
-                rewriteRecursively(callLiteral, liftedDnf, completedLiterals);
-        }
-
-        private void rewriteRecursively(AbstractCallLiteral callLiteral, Dnf dnf, List<Literal> completedLiterals) {
-                var rewrittenDnf = rewrite(dnf);
-                var rewrittenLiteral = callLiteral.withTarget(rewrittenDnf);
-                completedLiterals.add(rewrittenLiteral);
-        }
-
-        private void rewrite(AbstractCallLiteral callLiteral, Modality modality, Concreteness concreteness,
-                                                 PartialRelation partialRelation, Deque<Literal> workList) {
-                var rewriter = relationRewriterMap.get(partialRelation);
-                if (rewriter == null) {
-                        throw new IllegalArgumentException("Do not know how to interpret partial relation: " + partialRelation);
-                }
-                var literals = rewriter.rewriteLiteral(callLiteral, modality, concreteness);
-                int length = literals.size();
-                for (int i = length - 1; i >= 0; i--) {
-                        workList.addFirst(literals.get(i));
-                }
-        }
 }
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 396c2dcc..579b08dd 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
@@ -48,7 +48,7 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
                 refiners = new HashMap<>(refinerFactories.size());
                 createRefiners();
 
-                storageRefiners = storeAdapter.createRepresentationRefiners(model);
+                storageRefiners = storeAdapter.createStprageRefiner(model);
 
                 nodeCountInterpretation = model.getInterpretation(NODE_COUNT_SYMBOL);
         }
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 f7a91284..2af84e2d 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
@@ -10,7 +10,9 @@ 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.refinement.DefaultStorageRefiner;
@@ -38,16 +40,6 @@ public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder<ReasoningS
                         new LinkedHashMap<>();
         private final Map<AnySymbol, StorageRefiner.Factory<?>> registeredStorageRefiners = new LinkedHashMap<>();
         private final List<PartialModelInitializer> initializers = new ArrayList<>();
-        private int initialNodeCount = 0;
-
-        @Override
-        public ReasoningBuilder initialNodeCount(int nodeCount) {
-                if (nodeCount < 0) {
-                        throw new IllegalArgumentException("Initial model size must not be negative");
-                }
-                initialNodeCount = nodeCount;
-                return this;
-        }
 
         @Override
         public ReasoningBuilder partialSymbol(AnyPartialSymbolTranslator translator) {
@@ -81,6 +73,16 @@ public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder<ReasoningS
         }
 
         @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);
         }
@@ -114,7 +116,7 @@ public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder<ReasoningS
 
         @Override
         public ReasoningStoreAdapterImpl doBuild(ModelStore store) {
-                return new ReasoningStoreAdapterImpl(store, initialNodeCount, Collections.unmodifiableMap(symbolInterpreters),
+                return new ReasoningStoreAdapterImpl(store, Collections.unmodifiableMap(symbolInterpreters),
                                 Collections.unmodifiableMap(symbolRefiners), getStorageRefiners(store),
                                 Collections.unmodifiableList(initializers));
         }
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 e8b581c6..3dac53ef 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
@@ -14,6 +14,7 @@ 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.seed.ModelSeed;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
@@ -26,23 +27,18 @@ class ReasoningStoreAdapterImpl implements ReasoningStoreAdapter {
         private final ModelStore store;
         private final Map<AnyPartialSymbol, PartialInterpretation.Factory<?, ?>> symbolInterpreters;
         private final Map<AnyPartialSymbol, PartialInterpretationRefiner.Factory<?, ?>> symbolRefiners;
-        private final Map<AnySymbol, StorageRefiner.Factory<?>> representationRefiners;
-        private final Object initialModelLock = new Object();
-        private final int initialNodeCount;
-        private List<PartialModelInitializer> initializers;
-        private long initialCommitId = Model.NO_STATE_ID;
+        private final Map<AnySymbol, StorageRefiner.Factory<?>> storageRefiners;
+        private final List<PartialModelInitializer> initializers;
 
         ReasoningStoreAdapterImpl(ModelStore store,
-                                                          int initialNodeCount,
                                                           Map<AnyPartialSymbol, PartialInterpretation.Factory<?, ?>> symbolInterpreters,
                                                           Map<AnyPartialSymbol, PartialInterpretationRefiner.Factory<?, ?>> symbolRefiners,
-                                                          Map<AnySymbol, StorageRefiner.Factory<?>> representationRefiners,
+                                                          Map<AnySymbol, StorageRefiner.Factory<?>> storageRefiners,
                                                           List<PartialModelInitializer> initializers) {
                 this.store = store;
-                this.initialNodeCount = initialNodeCount;
                 this.symbolInterpreters = symbolInterpreters;
                 this.symbolRefiners = symbolRefiners;
-                this.representationRefiners = representationRefiners;
+                this.storageRefiners = storageRefiners;
                 this.initializers = initializers;
         }
 
@@ -73,44 +69,32 @@ class ReasoningStoreAdapterImpl implements ReasoningStoreAdapter {
                 return symbolRefiners;
         }
 
-        StorageRefiner[] createRepresentationRefiners(Model model) {
-                var refiners = new StorageRefiner[representationRefiners.size()];
+        StorageRefiner[] createStprageRefiner(Model model) {
+                var refiners = new StorageRefiner[storageRefiners.size()];
                 int i = 0;
-                for (var entry : representationRefiners.entrySet()) {
+                for (var entry : storageRefiners.entrySet()) {
                         var symbol = entry.getKey();
                         var factory = entry.getValue();
-                        refiners[i] = createRepresentationRefiner(factory, model, symbol);
+                        refiners[i] = createStorageRefiner(factory, model, symbol);
+                        i++;
                 }
                 return refiners;
         }
 
-        private <T> StorageRefiner createRepresentationRefiner(
-                        StorageRefiner.Factory<T> factory, Model model, AnySymbol symbol) {
+        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);
         }
 
-        @Override
-        public Model createInitialModel() {
-                synchronized (initialModelLock) {
-                        if (initialCommitId == Model.NO_STATE_ID) {
-                                return doCreateInitialModel();
-                        }
-                        return store.createModelForState(initialCommitId);
-                }
-        }
-
-        private Model doCreateInitialModel() {
+        public Model createInitialModel(ModelSeed modelSeed) {
                 var model = store.createEmptyModel();
-                model.getInterpretation(ReasoningAdapterImpl.NODE_COUNT_SYMBOL).put(Tuple.of(), initialNodeCount);
+                model.getInterpretation(ReasoningAdapterImpl.NODE_COUNT_SYMBOL).put(Tuple.of(), modelSeed.getNodeCount());
                 for (var initializer : initializers) {
-                        initializer.initialize(model, initialNodeCount);
+                        initializer.initialize(model, modelSeed);
                 }
                 model.getAdapter(ModelQueryAdapter.class).flushChanges();
-                initialCommitId = model.commit();
-                initializers = null;
                 return model;
         }
 
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
index da8ae0a8..6ad35c20 100644
--- 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
@@ -7,11 +7,15 @@ 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(AbstractCallLiteral literal, Modality modality, Concreteness concreteness);
+        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/QueryBasedRelationRewriter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/QueryBasedRelationRewriter.java
index 3be9e9ac..78fdbb89 100644
--- 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
@@ -5,30 +5,49 @@
  */
 package tools.refinery.store.reasoning.interpretation;
 
-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.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 Query<Boolean> may;
-        private final Query<Boolean> must;
-        private final Query<Boolean> candidateMay;
-        private final Query<Boolean> candidateMust;
+        private final RelationalQuery may;
+        private final RelationalQuery must;
+        private final RelationalQuery candidateMay;
+        private final RelationalQuery candidateMust;
 
-        public QueryBasedRelationRewriter(Query<Boolean> may, Query<Boolean> must, Query<Boolean> candidateMay,
-                                                                          Query<Boolean> 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(AbstractCallLiteral literal, Modality modality, Concreteness concreteness) {
+        public List<Literal> rewriteLiteral(Set<Variable> positiveVariables, AbstractCallLiteral literal,
+                                                                                Modality modality, Concreteness concreteness) {
                 var query = switch (concreteness) {
                         case PARTIAL -> switch (modality) {
                                 case MAY -> may;
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 2e68fa3e..6ac3efc0 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,9 +5,7 @@
  */
 package tools.refinery.store.reasoning.lifting;
 
-import tools.refinery.store.query.dnf.Dnf;
-import tools.refinery.store.query.dnf.DnfClause;
-import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.dnf.*;
 import tools.refinery.store.query.equality.DnfEqualityChecker;
 import tools.refinery.store.query.literal.Literal;
 import tools.refinery.store.reasoning.literal.Concreteness;
@@ -25,6 +23,16 @@ public class DnfLifter {
                 return query.withDnf(liftedDnf);
         }
 
+        public <T> 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);
         }
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/ConcreteSymbolRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/ConcreteSymbolRefiner.java
index 756118a0..ebb9b824 100644
--- 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
@@ -13,39 +13,26 @@ import tools.refinery.store.tuple.Tuple;
 
 import java.util.Objects;
 
-public class ConcreteSymbolRefiner<A, C> implements PartialInterpretationRefiner<A, C> {
-        private final ReasoningAdapter adapter;
-        private final PartialSymbol<A, C> partialSymbol;
+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) {
-                this.adapter = adapter;
-                this.partialSymbol = partialSymbol;
+                super(adapter, partialSymbol);
                 interpretation = adapter.getModel().getInterpretation(concreteSymbol);
         }
 
         @Override
-        public ReasoningAdapter getAdapter() {
-                return adapter;
-        }
-
-        @Override
-        public PartialSymbol<A, C> getPartialSymbol() {
-                return partialSymbol;
-        }
-
-        @Override
         public boolean merge(Tuple key, A value) {
                 var currentValue = interpretation.get(key);
-                var mergedValue = partialSymbol.abstractDomain().commonRefinement(currentValue, value);
+                var mergedValue = getPartialSymbol().abstractDomain().commonRefinement(currentValue, value);
                 if (!Objects.equals(currentValue, mergedValue)) {
                         interpretation.put(key, mergedValue);
                 }
                 return true;
         }
 
-        public static <A1, C1> PartialInterpretationRefiner.Factory<A1, C1> of(Symbol<A1> concreteSymbol) {
+        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
index 0d7d6c5c..d4ec2e8b 100644
--- 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
@@ -6,18 +6,17 @@
 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 = (symbol, model) -> {
-                var interpretation = model.getInterpretation(symbol);
-                return new DefaultStorageRefiner<>(interpretation);
-        };
+        private static final StorageRefiner.Factory<Object> FACTORY = DefaultStorageRefiner::new;
 
         private final Interpretation<T> interpretation;
 
-        public DefaultStorageRefiner(Interpretation<T> interpretation) {
-                this.interpretation = interpretation;
+        public DefaultStorageRefiner(Symbol<T> symbol, Model model) {
+                interpretation = model.getInterpretation(symbol);
         }
 
         @Override
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
index 79c1670f..0c82695c 100644
--- 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
@@ -6,8 +6,9 @@
 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, int nodeCount);
+        void initialize(Model model, ModelSeed modelSeed);
 }
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
index b5a3d844..8b1c3bb3 100644
--- 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
@@ -75,7 +75,7 @@ record MapBasedSeed<T>(int arity, Class<T> valueType, T reducedValue, Map<Tuple,
                 private boolean moveToNext() {
                         do {
                                 increment();
-                        } while (!checkValue());
+                        } while (state != State.TERMINATED && !checkValue());
                         return state != State.TERMINATED;
                 }
 
@@ -89,16 +89,10 @@ record MapBasedSeed<T>(int arity, Class<T> valueType, T reducedValue, Map<Tuple,
                                 counter[i] = 0;
                                 i--;
                         }
+                        state = State.TERMINATED;
                 }
 
                 private boolean checkValue() {
-                        if (state == State.TERMINATED) {
-                                return false;
-                        }
-                        if (counter[0] >= nodeCount) {
-                                state = State.TERMINATED;
-                                return false;
-                        }
                         key = Tuple.of(counter);
                         var valueInMap = map.get(key);
                         if (Objects.equals(valueInMap, defaultValue)) {
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..3641730d
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/ModelSeed.java
@@ -0,0 +1,86 @@
+/*
+ * 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.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 <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 64b98683..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
@@ -42,7 +42,7 @@ public interface Seed<T> {
         class Builder<T> {
                 private final int arity;
                 private final Class<T> valueType;
-                private final T reducedValue;
+                private T reducedValue;
                 private final Map<Tuple, T> map = new LinkedHashMap<>();
 
                 private Builder(int arity, Class<T> valueType, T reducedValue) {
@@ -51,6 +51,11 @@ public interface Seed<T> {
                         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));
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
index 884d6515..9af457d8 100644
--- 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
@@ -7,21 +7,22 @@ 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 Seed<T> seed;
+        private final PartialSymbol<T, ?> partialSymbol;
 
-        public SeedInitializer(Symbol<T> symbol, Seed<T> seed) {
+        public SeedInitializer(Symbol<T> symbol, PartialSymbol<T, ?> partialSymbol) {
                 this.symbol = symbol;
-                this.seed = seed;
+                this.partialSymbol = partialSymbol;
         }
 
         @Override
-        public void initialize(Model model, int nodeCount) {
+        public void initialize(Model model, ModelSeed modelSeed) {
                 var interpretation = model.getInterpretation(symbol);
-                var cursor = seed.getCursor(symbol.defaultValue(), nodeCount);
+                var cursor = modelSeed.getCursor(partialSymbol, symbol.defaultValue());
                 interpretation.putAll(cursor);
         }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialRelationTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialRelationTranslator.java
index fe8e8d6c..aee74eb3 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialRelationTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialRelationTranslator.java
@@ -32,11 +32,11 @@ import tools.refinery.store.representation.TruthValue;
 public final class PartialRelationTranslator extends PartialSymbolTranslator<TruthValue, Boolean> {
         private final PartialRelation partialRelation;
         private PartialRelationRewriter rewriter;
-        private Query<Boolean> query;
-        private Query<Boolean> may;
-        private Query<Boolean> must;
-        private Query<Boolean> candidateMay;
-        private Query<Boolean> candidateMust;
+        private RelationalQuery query;
+        private RelationalQuery may;
+        private RelationalQuery must;
+        private RelationalQuery candidateMay;
+        private RelationalQuery candidateMust;
         private RoundingMode roundingMode;
 
         private PartialRelationTranslator(PartialRelation partialRelation) {
@@ -197,20 +197,41 @@ public final class PartialRelationTranslator extends PartialSymbolTranslator<Tru
         }
 
         private void liftQueries(ModelStoreBuilder storeBuilder) {
-                if (query != null) {
-                        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);
-                        }
+                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);
                 }
         }
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialSymbolTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialSymbolTranslator.java
index 07d1d19b..542acdb3 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialSymbolTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialSymbolTranslator.java
@@ -12,7 +12,6 @@ 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.Seed;
 import tools.refinery.store.reasoning.seed.SeedInitializer;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
@@ -100,20 +99,6 @@ public abstract sealed class PartialSymbolTranslator<A, C> implements AnyPartial
                 return this;
         }
 
-        public <T> PartialSymbolTranslator<A, C> seed(Seed<T> seed) {
-                if (storageSymbol == null) {
-                        throw new IllegalArgumentException("Seed requires setting a storage symbol");
-                }
-                if (!seed.valueType().equals(storageSymbol.valueType())) {
-                        throw new IllegalArgumentException("Seed type %s does not match storage symbol type %s"
-                                        .formatted(seed.valueType(), storageSymbol.valueType()));
-                }
-                // The guard clause only allows a well-typed seed.
-                @SuppressWarnings("unchecked")
-                var typedStorageSymbol = (Symbol<T>) storageSymbol;
-                return initializer(new SeedInitializer<>(typedStorageSymbol, seed));
-        }
-
         @Override
         public void configure(ModelStoreBuilder storeBuilder) {
                 checkNotConfigured();
@@ -132,6 +117,7 @@ public abstract sealed class PartialSymbolTranslator<A, C> implements AnyPartial
                                 registerStorageRefiner(reasoningBuilder, storageRefiner);
                         }
                 }
+                createFallbackInitializer();
                 if (initializer != null) {
                         reasoningBuilder.initializer(initializer);
                 }
@@ -144,6 +130,17 @@ public abstract sealed class PartialSymbolTranslator<A, C> implements AnyPartial
                 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;
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..c7bc9fff
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/EqualsRelationRewriter.java
@@ -0,0 +1,84 @@
+/*
+ * 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.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(UpperCardinalityView upperCardinalityView) {
+                var may = Query.of("MAY_EQUALS", (builder, p1, p2) -> builder
+                                .clause(
+                                                p1.isEquivalent(p2),
+                                                upperCardinalityView.call(p1, Variable.of(UpperCardinality.class))
+                                ));
+                var must = Query.of("MUST_EQUALS", (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..6917b8ed
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectInitializer.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.multiobject;
+
+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.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;
+
+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 = new CardinalityInterval[modelSeed.getNodeCount()];
+                Arrays.fill(intervals, CardinalityIntervals.SET);
+                initializeExists(intervals, modelSeed);
+                initializeEquals(intervals, modelSeed);
+                var countInterpretation = model.getInterpretation(countSymbol);
+                for (int i = 0; i < intervals.length; i++) {
+                        var interval = intervals[i];
+                        if (interval.isEmpty()) {
+                                throw new IllegalArgumentException("Inconsistent existence or equality for node " + i);
+                        }
+                        countInterpretation.put(Tuple.of(i), intervals[i]);
+                }
+        }
+
+        private void initializeExists(CardinalityInterval[] intervals, ModelSeed modelSeed) {
+                var cursor = modelSeed.getCursor(ReasoningAdapter.EXISTS_SYMBOL, TruthValue.UNKNOWN);
+                while (cursor.move()) {
+                        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 IllegalArgumentException("Inconsistent existence for node " + i);
+                        default -> throw new IllegalArgumentException("Invalid existence truth value %s for node %d"
+                                        .formatted(cursor.getValue(), i));
+                        }
+                }
+        }
+
+        private void initializeEquals(CardinalityInterval[] intervals, ModelSeed modelSeed) {
+                var seed = modelSeed.getSeed(ReasoningAdapter.EQUALS_SYMBOL);
+                var cursor = seed.getCursor(TruthValue.FALSE, modelSeed.getNodeCount());
+                while (cursor.move()) {
+                        var key = cursor.getKey();
+                        int i = key.get(0);
+                        int otherIndex = key.get(1);
+                        if (i != otherIndex) {
+                                throw new IllegalArgumentException("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 IllegalArgumentException("Inconsistent equality for node " + i);
+                        default -> throw new IllegalArgumentException("Invalid equality truth value %s for node %d"
+                                        .formatted(cursor.getValue(), i));
+                        }
+                }
+                for (int i = 0; i < intervals.length; i++) {
+                        if (seed.get(Tuple.of(i, i)) == TruthValue.FALSE) {
+                                throw new IllegalArgumentException("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..0367214b
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/multiobject/MultiObjectTranslator.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.translator.multiobject;
+
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.model.ModelStoreConfiguration;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.ReasoningBuilder;
+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.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.constant;
+import static tools.refinery.store.query.term.int_.IntTerms.greaterEq;
+import static tools.refinery.store.query.term.uppercardinality.UpperCardinalityTerms.constant;
+import static tools.refinery.store.query.term.uppercardinality.UpperCardinalityTerms.greaterEq;
+
+public class MultiObjectTranslator implements ModelStoreConfiguration {
+        private final Symbol<CardinalityInterval> countSymbol = Symbol.of("COUNT", 1, CardinalityInterval.class,
+                        null);
+        private final LowerCardinalityView lowerCardinalityView = new LowerCardinalityView(countSymbol);
+        private final UpperCardinalityView upperCardinalityView = new UpperCardinalityView(countSymbol);
+
+        @Override
+        public void apply(ModelStoreBuilder storeBuilder) {
+                storeBuilder.symbol(countSymbol);
+
+                storeBuilder.with(PartialRelationTranslator.of(ReasoningAdapter.EXISTS_SYMBOL)
+                                .may(Query.of("MAY_EXISTS", (builder, p1) -> builder
+                                                .clause(UpperCardinality.class, upper -> List.of(
+                                                                upperCardinalityView.call(p1, upper),
+                                                                check(greaterEq(upper, constant(UpperCardinalities.ONE)))
+                                                ))))
+                                .must(Query.of("MUST_EXISTS", (builder, p1) -> builder
+                                                .clause(Integer.class, lower -> List.of(
+                                                                lowerCardinalityView.call(p1, lower),
+                                                                check(greaterEq(lower, constant(1)))
+                                                ))))
+                                .roundingMode(RoundingMode.PREFER_FALSE)
+                                .refiner(ExistsRefiner.of(countSymbol)));
+
+                storeBuilder.with(PartialRelationTranslator.of(ReasoningAdapter.EQUALS_SYMBOL)
+                                .rewriter(EqualsRelationRewriter.of(upperCardinalityView))
+                                .refiner(EqualsRefiner.of(countSymbol)));
+
+                var reasoningBuilder = storeBuilder.getAdapter(ReasoningBuilder.class);
+                reasoningBuilder.initializer(new MultiObjectInitializer(countSymbol));
+                reasoningBuilder.storageRefiner(countSymbol, MultiObjectStorageRefiner::new);
+        }
+}
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/test/java/tools/refinery/store/reasoning/PartialModelTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/PartialModelTest.java
index f948ad6a..b2188f5d 100644
--- a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/PartialModelTest.java
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/PartialModelTest.java
@@ -14,78 +14,95 @@ import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
 import tools.refinery.store.query.view.ForbiddenView;
 import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.reasoning.seed.Seed;
+import tools.refinery.store.reasoning.seed.ModelSeed;
 import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
+import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.tuple.Tuple;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.nullValue;
 import static tools.refinery.store.query.literal.Literals.not;
+import static tools.refinery.store.reasoning.ReasoningAdapter.EQUALS_SYMBOL;
+import static tools.refinery.store.reasoning.ReasoningAdapter.EXISTS_SYMBOL;
 import static tools.refinery.store.reasoning.literal.PartialLiterals.may;
+import static tools.refinery.store.reasoning.literal.PartialLiterals.must;
 
 class PartialModelTest {
         @Test
         void partialModelTest() {
-                var personStorage = Symbol.of("Person", 1, TruthValue.class, TruthValue.FALSE);
-                var friendStorage = Symbol.of("friend", 2, TruthValue.class, TruthValue.UNKNOWN);
-
                 var person = new PartialRelation("Person", 1);
                 var friend = new PartialRelation("friend", 2);
                 var lonely = new PartialRelation("lonely", 1);
 
+                var personStorage = Symbol.of("Person", 1, TruthValue.class, TruthValue.FALSE);
+                var friendStorage = Symbol.of("friend", 2, TruthValue.class, TruthValue.UNKNOWN);
+
                 var store = ModelStore.builder()
                                 .with(ViatraModelQueryAdapter.builder())
-                                .with(ReasoningAdapter.builder()
-                                                .initialNodeCount(4))
-                                .with(PartialRelationTranslator.of(ReasoningAdapter.EXISTS_SYMBOL)
-                                                .symbol(Symbol.of("exists", 1, TruthValue.class, TruthValue.FALSE))
-                                                .seed(Seed.builder(ReasoningAdapter.EXISTS_SYMBOL)
-                                                                .put(Tuple.of(0), TruthValue.TRUE)
-                                                                .put(Tuple.of(1), TruthValue.UNKNOWN)
-                                                                .put(Tuple.of(2), TruthValue.TRUE)
-                                                                .put(Tuple.of(3), TruthValue.TRUE)
-                                                                .build()))
+                                .with(ReasoningAdapter.builder())
+                                .with(new MultiObjectTranslator())
                                 .with(PartialRelationTranslator.of(person)
-                                                .symbol(personStorage)
-                                                .seed(Seed.builder(personStorage)
-                                                                .put(Tuple.of(0), TruthValue.TRUE)
-                                                                .put(Tuple.of(1), TruthValue.TRUE)
-                                                                .put(Tuple.of(2), TruthValue.UNKNOWN)
-                                                                .build()))
+                                                .symbol(personStorage))
                                 .with(PartialRelationTranslator.of(friend)
                                                 .symbol(friendStorage)
-                                                .may(Query.of((builder, p1, p2) -> builder.clause(
+                                                .may(Query.of("mayPerson", (builder, p1, p2) -> builder.clause(
                                                                 may(person.call(p1)),
                                                                 may(person.call(p2)),
-                                                                // not(must(EQUALS_SYMBOL.call(p1, p2))),
+                                                                not(must(EQUALS_SYMBOL.call(p1, p2))),
                                                                 not(new ForbiddenView(friendStorage).call(p1, p2))
-                                                )))
-                                                .seed(Seed.builder(friendStorage)
-                                                                .put(Tuple.of(0, 1), TruthValue.TRUE)
-                                                                .put(Tuple.of(1, 2), TruthValue.FALSE)
-                                                                .build()))
+                                                ))))
                                 .with(PartialRelationTranslator.of(lonely)
-                                                .query(Query.of((builder, p1) -> builder.clause(
+                                                .query(Query.of("lonely", (builder, p1) -> builder.clause(
                                                                 person.call(p1),
                                                                 not(friend.call(p1, Variable.of())))
                                                 )))
                                 .build();
 
-                var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel();
+                var modelSeed = ModelSeed.builder(4)
+                                .seed(EXISTS_SYMBOL, builder -> builder
+                                                .put(Tuple.of(0), TruthValue.TRUE)
+                                                .put(Tuple.of(1), TruthValue.UNKNOWN)
+                                                .put(Tuple.of(2), TruthValue.TRUE)
+                                                .put(Tuple.of(3), TruthValue.TRUE))
+                                .seed(EQUALS_SYMBOL, builder -> builder
+                                                .put(Tuple.of(0, 0), TruthValue.TRUE)
+                                                .put(Tuple.of(1, 1), TruthValue.UNKNOWN)
+                                                .put(Tuple.of(2, 2), TruthValue.UNKNOWN)
+                                                .put(Tuple.of(3, 3), TruthValue.TRUE))
+                                .seed(person, builder -> builder
+                                                .put(Tuple.of(0), TruthValue.TRUE)
+                                                .put(Tuple.of(1), TruthValue.TRUE)
+                                                .put(Tuple.of(2), TruthValue.UNKNOWN))
+                                .seed(friend, builder -> builder
+                                                .reducedValue(TruthValue.UNKNOWN)
+                                                .put(Tuple.of(0, 1), TruthValue.TRUE)
+                                                .put(Tuple.of(1, 2), TruthValue.FALSE))
+                                .build();
+                var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
 
                 var queryAdapter = model.getAdapter(ModelQueryAdapter.class);
                 var reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
                 var friendInterpretation = reasoningAdapter.getPartialInterpretation(Concreteness.PARTIAL, friend);
+                var friendRefiner = reasoningAdapter.getRefiner(friend);
+
                 assertThat(friendInterpretation.get(Tuple.of(0, 1)), is(TruthValue.TRUE));
                 assertThat(friendInterpretation.get(Tuple.of(1, 0)), is(TruthValue.UNKNOWN));
                 assertThat(friendInterpretation.get(Tuple.of(3, 0)), is(TruthValue.FALSE));
-                var friendRefiner = reasoningAdapter.getRefiner(friend);
+
                 assertThat(friendRefiner.merge(Tuple.of(0, 1), TruthValue.FALSE), is(true));
                 assertThat(friendRefiner.merge(Tuple.of(1, 0), TruthValue.TRUE), is(true));
+                var splitResult = reasoningAdapter.split(1);
+                assertThat(splitResult, not(nullValue()));
+                var newPerson = splitResult.get(0);
                 queryAdapter.flushChanges();
+
                 assertThat(friendInterpretation.get(Tuple.of(0, 1)), is(TruthValue.ERROR));
                 assertThat(friendInterpretation.get(Tuple.of(1, 0)), is(TruthValue.TRUE));
+                assertThat(friendInterpretation.get(Tuple.of(0, newPerson)), is(TruthValue.ERROR));
+                assertThat(friendInterpretation.get(Tuple.of(newPerson, 0)), is(TruthValue.TRUE));
         }
 }