27 files changed, 99 insertions, 70 deletions

diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java
index 7f0ef8b4..a9b3141a 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
@@ -1,11 +1,12 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning;
 
 import org.jetbrains.annotations.Nullable;
+import tools.refinery.logic.AbstractValue;
 import tools.refinery.store.adapter.ModelAdapter;
 import tools.refinery.store.reasoning.internal.ReasoningBuilderImpl;
 import tools.refinery.store.reasoning.interpretation.AnyPartialInterpretation;
@@ -27,17 +28,19 @@ public interface ReasoningAdapter extends ModelAdapter {
 
         default AnyPartialInterpretation getPartialInterpretation(Concreteness concreteness,
                                                                                                                           AnyPartialSymbol partialSymbol) {
-                return getPartialInterpretation(concreteness, (PartialSymbol<?, ?>) partialSymbol);
+                var typedPartialSymbol = (PartialSymbol<?, ?>) partialSymbol;
+                return getPartialInterpretation(concreteness, typedPartialSymbol);
         }
 
-        <A, C> PartialInterpretation<A, C> getPartialInterpretation(Concreteness concreteness,
-                                                                                                                                PartialSymbol<A, C> partialSymbol);
+        <A extends AbstractValue<A, C>, C> PartialInterpretation<A, C> getPartialInterpretation(
+                        Concreteness concreteness, PartialSymbol<A, C> partialSymbol);
 
         default AnyPartialInterpretationRefiner getRefiner(AnyPartialSymbol partialSymbol) {
-                return getRefiner((PartialSymbol<?, ?>) partialSymbol);
+                var typedPartialSymbol = (PartialSymbol<?, ?>) partialSymbol;
+                return getRefiner(typedPartialSymbol);
         }
 
-        <A, C> PartialInterpretationRefiner<A, C> getRefiner(PartialSymbol<A, C> partialSymbol);
+        <A extends AbstractValue<A, C>, C> PartialInterpretationRefiner<A, C> getRefiner(PartialSymbol<A, C> partialSymbol);
 
         @Nullable
         Tuple1 split(int parentMultiObject);
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
index 79e0237c..86256331 100644
--- 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
@@ -1,10 +1,11 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.actions;
 
+import tools.refinery.logic.AbstractValue;
 import tools.refinery.store.dse.transition.actions.AbstractActionLiteral;
 import tools.refinery.store.dse.transition.actions.BoundActionLiteral;
 import tools.refinery.store.model.Model;
@@ -15,7 +16,7 @@ import tools.refinery.store.tuple.Tuple;
 
 import java.util.List;
 
-public class MergeActionLiteral<A, C> extends AbstractActionLiteral {
+public class MergeActionLiteral<A extends AbstractValue<A, C>, C> extends AbstractActionLiteral {
         private final PartialSymbol<A, C> partialSymbol;
         private final List<NodeVariable> parameters;
         private final A value;
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
index 7b4c5446..e8e6880a 100644
--- 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
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.reasoning.actions;
 
+import tools.refinery.logic.AbstractValue;
 import tools.refinery.logic.term.NodeVariable;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.reasoning.representation.PartialSymbol;
@@ -17,8 +18,8 @@ public final class 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) {
+        public static <A extends AbstractValue<A, C>, C> MergeActionLiteral<A, C> merge(
+                        PartialSymbol<A, C> partialSymbol, A value, NodeVariable... parameters) {
                 return new MergeActionLiteral<>(partialSymbol, value, List.of(parameters));
         }
 
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 a287cce3..386ae1d8 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
@@ -1,11 +1,12 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.internal;
 
 import org.jetbrains.annotations.Nullable;
+import tools.refinery.logic.AbstractValue;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.reasoning.ReasoningAdapter;
@@ -49,7 +50,7 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
                 createPartialInterpretations();
 
                 var refinerFactories = storeAdapter.getSymbolRefiners();
-                refiners = new HashMap<>(refinerFactories.size());
+                refiners = HashMap.newHashMap(refinerFactories.size());
                 createRefiners();
 
                 storageRefiners = storeAdapter.createStorageRefiner(model);
@@ -69,7 +70,7 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
                 for (int i = 0; i < concretenessLength; i++) {
                         var concreteness = Concreteness.values()[i];
                         if (supportedInterpretations.contains(concreteness)) {
-                                partialInterpretations[i] = new HashMap<>(interpretationFactories.size());
+                                partialInterpretations[i] = HashMap.newHashMap(interpretationFactories.size());
                         }
                 }
                 // Create the partial interpretations in order so that factories may refer to interpretations of symbols
@@ -87,7 +88,7 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
                 }
         }
 
-        private <A, C> PartialInterpretation<A, C> createPartialInterpretation(
+        private <A extends AbstractValue<A, C>, 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")
@@ -107,7 +108,7 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
                 }
         }
 
-        private <A, C> PartialInterpretationRefiner<A, C> createRefiner(
+        private <A extends AbstractValue<A, C>, 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")
@@ -126,8 +127,8 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
         }
 
         @Override
-        public <A, C> PartialInterpretation<A, C> getPartialInterpretation(Concreteness concreteness,
-                                                                                                                                           PartialSymbol<A, C> partialSymbol) {
+        public <A extends AbstractValue<A, C>, 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);
@@ -143,7 +144,8 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
         }
 
         @Override
-        public <A, C> PartialInterpretationRefiner<A, C> getRefiner(PartialSymbol<A, C> partialSymbol) {
+        public <A extends AbstractValue<A, C>, 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);
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
index ed291eac..4f51957b 100644
--- 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
@@ -5,11 +5,13 @@
  */
 package tools.refinery.store.reasoning.interpretation;
 
+import tools.refinery.logic.AbstractValue;
 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> {
+public abstract class AbstractPartialInterpretation<A extends AbstractValue<A, C>, C>
+                implements PartialInterpretation<A, C> {
         private final ReasoningAdapter adapter;
         private final PartialSymbol<A, C> partialSymbol;
         private final Concreteness concreteness;
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
index 86ffe751..5a304030 100644
--- 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
@@ -1,10 +1,11 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.interpretation;
 
+import tools.refinery.logic.AbstractValue;
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.reasoning.ReasoningAdapter;
@@ -14,7 +15,7 @@ import tools.refinery.store.tuple.Tuple;
 
 import java.util.Set;
 
-public non-sealed interface PartialInterpretation<A, C> extends AnyPartialInterpretation {
+public non-sealed interface PartialInterpretation<A extends AbstractValue<A, C>, C> extends AnyPartialInterpretation {
         @Override
         PartialSymbol<A, C> getPartialSymbol();
 
@@ -23,7 +24,7 @@ public non-sealed interface PartialInterpretation<A, C> extends AnyPartialInterp
         Cursor<Tuple, A> getAll();
 
         @FunctionalInterface
-        interface Factory<A, C> {
+        interface Factory<A extends AbstractValue<A, C>, C> {
                 PartialInterpretation<A, C> create(ReasoningAdapter adapter, Concreteness concreteness,
                                                                                    PartialSymbol<A, C> partialSymbol);
 
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
index a7fc5b7e..42943490 100644
--- 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
@@ -1,14 +1,16 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.refinement;
 
+import tools.refinery.logic.AbstractValue;
 import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.representation.PartialSymbol;
 
-public abstract class AbstractPartialInterpretationRefiner<A, C> implements PartialInterpretationRefiner<A, C> {
+public abstract class AbstractPartialInterpretationRefiner<A extends AbstractValue<A, C>, C>
+                implements PartialInterpretationRefiner<A, C> {
         private final ReasoningAdapter adapter;
         private final PartialSymbol<A, C> 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 ebb9b824..d6ac0e9d 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
@@ -1,10 +1,11 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.refinement;
 
+import tools.refinery.logic.AbstractValue;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.representation.PartialSymbol;
@@ -13,7 +14,8 @@ import tools.refinery.store.tuple.Tuple;
 
 import java.util.Objects;
 
-public class ConcreteSymbolRefiner<A, C> extends AbstractPartialInterpretationRefiner<A, C> {
+public class ConcreteSymbolRefiner<A extends AbstractValue<A, C>, C>
+                extends AbstractPartialInterpretationRefiner<A, C> {
         private final Interpretation<A> interpretation;
 
         public ConcreteSymbolRefiner(ReasoningAdapter adapter, PartialSymbol<A, C> partialSymbol,
@@ -25,14 +27,14 @@ public class ConcreteSymbolRefiner<A, C> extends AbstractPartialInterpretationRe
         @Override
         public boolean merge(Tuple key, A value) {
                 var currentValue = interpretation.get(key);
-                var mergedValue = getPartialSymbol().abstractDomain().commonRefinement(currentValue, value);
+                var mergedValue = currentValue.meet(value);
                 if (!Objects.equals(currentValue, mergedValue)) {
                         interpretation.put(key, mergedValue);
                 }
                 return true;
         }
 
-        public static <A1, C1> Factory<A1, C1> of(Symbol<A1> concreteSymbol) {
+        public static <A1 extends AbstractValue<A1, C1>, 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/PartialInterpretationRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/PartialInterpretationRefiner.java
index f48d1d1f..c8b182b8 100644
--- 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
@@ -1,22 +1,24 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.refinement;
 
+import tools.refinery.logic.AbstractValue;
 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 {
+public non-sealed interface PartialInterpretationRefiner<A extends AbstractValue<A, C>, C>
+                extends AnyPartialInterpretationRefiner {
         @Override
         PartialSymbol<A, C> getPartialSymbol();
 
         boolean merge(Tuple key, A value);
 
         @FunctionalInterface
-        interface Factory<A, C> {
+        interface Factory<A extends AbstractValue<A, C>, 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/RefinementBasedInitializer.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/refinement/RefinementBasedInitializer.java
index b6bccb01..1a2c03a6 100644
--- 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
@@ -1,16 +1,17 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.refinement;
 
+import tools.refinery.logic.AbstractValue;
 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 {
+public class RefinementBasedInitializer<A extends AbstractValue<A, C>, C> implements PartialModelInitializer {
         private final PartialSymbol<A, C> partialSymbol;
 
         public RefinementBasedInitializer(PartialSymbol<A, C> partialSymbol) {
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 236be7f8..88b98da8 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
@@ -1,14 +1,16 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.representation;
 
 import tools.refinery.logic.AbstractDomain;
+import tools.refinery.logic.AbstractValue;
 
-public record PartialFunction<A, C>(String name, int arity, AbstractDomain<A, C> abstractDomain)
-                implements AnyPartialFunction, PartialSymbol<A, C> {
+public record PartialFunction<A extends AbstractValue<A, C>, C>(
+                String name, int arity, AbstractDomain<A, C> abstractDomain) implements AnyPartialFunction,
+                PartialSymbol<A, C> {
         @Override
         public A defaultValue() {
                 return null;
@@ -21,7 +23,7 @@ public record PartialFunction<A, C>(String name, int arity, AbstractDomain<A, C>
 
         @Override
         public int hashCode() {
-                // Compare by identity to make hash table lookups more efficient.
+                // Compare by identity to make hash table look-ups more efficient.
                 return System.identityHashCode(this);
         }
 
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 6986d518..21cbfefa 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
@@ -1,13 +1,15 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.representation;
 
 import tools.refinery.logic.AbstractDomain;
+import tools.refinery.logic.AbstractValue;
 
-public sealed interface PartialSymbol<A, C> extends AnyPartialSymbol permits PartialFunction, PartialRelation {
+public sealed interface PartialSymbol<A extends AbstractValue<A, C>, C> extends AnyPartialSymbol
+                permits PartialFunction, PartialRelation {
         @Override
         AbstractDomain<A, C> abstractDomain();
 
@@ -17,7 +19,8 @@ public sealed interface PartialSymbol<A, C> extends AnyPartialSymbol permits Par
                 return new PartialRelation(name, arity);
         }
 
-        static <A, C> PartialFunction<A, C> of(String name, int arity, AbstractDomain<A, C> abstractDomain) {
+        static <A extends AbstractValue<A, C>, 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/ModelSeed.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/ModelSeed.java
index e6b3eaf9..9cd4862b 100644
--- 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
@@ -1,10 +1,11 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.seed;
 
+import tools.refinery.logic.AbstractValue;
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.representation.PartialSymbol;
@@ -29,7 +30,7 @@ public class ModelSeed {
                 return nodeCount;
         }
 
-        public <A> Seed<A> getSeed(PartialSymbol<A, ?> partialSymbol) {
+        public <A extends AbstractValue<A, ?>> Seed<A> getSeed(PartialSymbol<A, ?> partialSymbol) {
                 var seed = seeds.get(partialSymbol);
                 if (seed == null) {
                         throw new IllegalArgumentException("No seed for partial symbol " + partialSymbol);
@@ -48,7 +49,8 @@ public class ModelSeed {
                 return Collections.unmodifiableSet(seeds.keySet());
         }
 
-        public <A> Cursor<Tuple, A> getCursor(PartialSymbol<A, ?> partialSymbol, A defaultValue) {
+        public <A extends AbstractValue<A, ?>> Cursor<Tuple, A> getCursor(PartialSymbol<A, ?> partialSymbol,
+                                                                                                                                          A defaultValue) {
                 return getSeed(partialSymbol).getCursor(defaultValue, nodeCount);
         }
 
@@ -67,7 +69,7 @@ public class ModelSeed {
                         this.nodeCount = nodeCount;
                 }
 
-                public <A> Builder seed(PartialSymbol<A, ?> partialSymbol, Seed<A> seed) {
+                public <A extends AbstractValue<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()));
@@ -82,7 +84,8 @@ public class ModelSeed {
                         return this;
                 }
 
-                public <A> Builder seed(PartialSymbol<A, ?> partialSymbol, Consumer<Seed.Builder<A>> callback) {
+                public <A extends AbstractValue<A, ?>> Builder seed(PartialSymbol<A, ?> partialSymbol,
+                                                                                                                        Consumer<Seed.Builder<A>> callback) {
                         var builder = Seed.builder(partialSymbol);
                         callback.accept(builder);
                         return seed(partialSymbol, builder.build());
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 d9bad866..32562f01 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
@@ -1,10 +1,11 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.seed;
 
+import tools.refinery.logic.AbstractValue;
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.reasoning.representation.PartialSymbol;
 import tools.refinery.store.representation.Symbol;
@@ -33,7 +34,7 @@ public interface Seed<T> {
                 return builder(symbol.arity(), symbol.valueType(), symbol.defaultValue());
         }
 
-        static <T> Builder<T> builder(PartialSymbol<T, ?> partialSymbol) {
+        static <T extends AbstractValue<T, ?>> Builder<T> builder(PartialSymbol<T, ?> partialSymbol) {
                 return builder(partialSymbol.arity(), partialSymbol.abstractDomain().abstractType(),
                                 partialSymbol.defaultValue());
         }
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 9af457d8..138e3a64 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
@@ -1,16 +1,17 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.seed;
 
+import tools.refinery.logic.AbstractValue;
 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 {
+public class SeedInitializer<T extends AbstractValue<T, ?>> implements PartialModelInitializer {
         private final Symbol<T> symbol;
         private final PartialSymbol<T, ?> partialSymbol;
 
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 6cdb287d..f2583098 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
@@ -6,6 +6,7 @@
 package tools.refinery.store.reasoning.translator;
 
 import org.jetbrains.annotations.Nullable;
+import tools.refinery.logic.AbstractValue;
 import tools.refinery.store.dse.transition.DesignSpaceExplorationBuilder;
 import tools.refinery.store.dse.transition.Rule;
 import tools.refinery.store.dse.transition.objectives.Criterion;
@@ -25,8 +26,8 @@ import java.util.ArrayList;
 import java.util.List;
 
 @SuppressWarnings("UnusedReturnValue")
-public abstract sealed class PartialSymbolTranslator<A, C> implements AnyPartialSymbolTranslator
-                permits PartialRelationTranslator {
+public abstract sealed class PartialSymbolTranslator<A extends AbstractValue<A, C>, C>
+                implements AnyPartialSymbolTranslator permits PartialRelationTranslator {
         private final PartialSymbol<A, C> partialSymbol;
         private boolean configured = false;
         protected PartialInterpretationRefiner.Factory<A, C> interpretationRefiner;
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
index ef007efc..e83c33ac 100644
--- 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
@@ -64,7 +64,7 @@ class ContainmentLinkRefiner extends AbstractPartialInterpretationRefiner<TruthV
                 if (mustLinks.contains(factory.linkType)) {
                         return oldValue;
                 }
-                return new InferredContainment(oldValue.contains().merge(TruthValue.TRUE),
+                return new InferredContainment(oldValue.contains().meet(TruthValue.TRUE),
                                 addToSet(mustLinks, factory.linkType), oldValue.forbiddenLinks());
         }
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainsRefiner.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainsRefiner.java
index 3fe63339..00820040 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainsRefiner.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainsRefiner.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -23,7 +23,7 @@ class ContainsRefiner extends AbstractPartialInterpretationRefiner<TruthValue, B
 
         static {
                 var values = TruthValue.values();
-                EMPTY_VALUES = new LinkedHashMap<>(values.length);
+                EMPTY_VALUES = LinkedHashMap.newLinkedHashMap(values.length);
                 for (var value : values) {
                         EMPTY_VALUES.put(value, new InferredContainment(value, Set.of(), Set.of()));
                 }
@@ -53,7 +53,7 @@ class ContainsRefiner extends AbstractPartialInterpretationRefiner<TruthValue, B
         }
 
         public InferredContainment mergeLink(InferredContainment oldValue, TruthValue toMerge) {
-                var newContains = oldValue.contains().merge(toMerge);
+                var newContains = oldValue.contains().meet(toMerge);
                 if (newContains.equals(oldValue.contains())) {
                         return oldValue;
                 }
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
index 77c7aaf4..0b6503c3 100644
--- 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
@@ -31,11 +31,11 @@ final class InferredContainment {
                                                                                          Set<PartialRelation> forbiddenLinks) {
                 var result = contains;
                 if (!mustLinks.isEmpty()) {
-                        result = result.merge(TruthValue.TRUE);
+                        result = result.meet(TruthValue.TRUE);
                 }
                 boolean hasErrorLink = mustLinks.stream().anyMatch(forbiddenLinks::contains);
                 if (mustLinks.size() >= 2 || hasErrorLink) {
-                        result = result.merge(TruthValue.ERROR);
+                        result = result.meet(TruthValue.ERROR);
                 }
                 return result;
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInitializer.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInitializer.java
index 5bb1b967..84dcfdc5 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInitializer.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/crossreference/UndirectedCrossReferenceInitializer.java
@@ -73,7 +73,7 @@ class UndirectedCrossReferenceInitializer implements PartialModelInitializer {
                                 // Already processed entry.
                                 continue;
                         }
-                        var mergedValue = value.merge(oppositeValue == null ? defaultValue : oppositeValue);
+                        var mergedValue = value.meet(oppositeValue == null ? defaultValue : oppositeValue);
                         mergedMap.put(key, mergedValue);
                         if (first != second) {
                                 mergedMap.put(oppositeKey, mergedValue);
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
index a5047768..d1979b8c 100644
--- 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
@@ -131,7 +131,7 @@ public class MetamodelBuilder {
                         var oppositeInfo = referenceInfoMap.get(opposite);
                         validateOpposite(linkType, info, opposite, oppositeInfo);
                         targetMultiplicity = oppositeInfo.multiplicity();
-                        defaultValue = defaultValue.merge(oppositeInfo.defaultValue());
+                        defaultValue = defaultValue.meet(oppositeInfo.defaultValue());
                         if (oppositeInfo.containment()) {
                                 // Skip processing this reference and process it once we encounter its containment opposite.
                                 return;
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
index 0b89ec58..07595932 100644
--- 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
@@ -51,7 +51,7 @@ public class EqualsRefiner extends AbstractPartialInterpretationRefiner<TruthVal
                         return false;
                 }
                 var newCount = currentCount.meet(CardinalityIntervals.LONE);
-                if (newCount.isEmpty()) {
+                if (newCount.isError()) {
                         return false;
                 }
                 countInterpretation.put(unaryKey, newCount);
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
index 3908fedb..83fa4377 100644
--- 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
@@ -42,7 +42,7 @@ public class ExistsRefiner extends AbstractPartialInterpretationRefiner<TruthVal
                 }
                 default -> throw new IllegalArgumentException("Unknown TruthValue: " + value);
                 }
-                if (newCount.isEmpty()) {
+                if (newCount.isError()) {
                         return false;
                 }
                 countInterpretation.put(key, newCount);
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
index 694a800b..eb13174c 100644
--- 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
@@ -37,7 +37,7 @@ class MultiObjectInitializer implements PartialModelInitializer {
                 var uniqueTable = new HashMap<CardinalityInterval, CardinalityInterval>();
                 for (int i = 0; i < intervals.length; i++) {
                         var interval = intervals[i];
-                        if (interval.isEmpty()) {
+                        if (interval.isError()) {
                                 throw new TranslationException(ReasoningAdapter.EXISTS_SYMBOL,
                                                 "Inconsistent existence or equality for node " + i);
                         }
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
index 147ae486..ab401f9e 100644
--- 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
@@ -28,7 +28,7 @@ class MultiObjectStorageRefiner implements StorageRefiner {
                         return false;
                 }
                 var newParentCount = parentCount.take(1);
-                if (newParentCount.isEmpty()) {
+                if (newParentCount.isError()) {
                         return false;
                 }
                 var childKey = Tuple.of(childNode);
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
index 7290ab40..75828086 100644
--- 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
@@ -1,11 +1,11 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.translator.opposite;
 
-
+import tools.refinery.logic.AbstractValue;
 import tools.refinery.store.map.AnyVersionedMap;
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.reasoning.ReasoningAdapter;
@@ -17,7 +17,7 @@ import tools.refinery.store.tuple.Tuple;
 
 import java.util.Set;
 
-class OppositeInterpretation<A, C> extends AbstractPartialInterpretation<A, C> {
+class OppositeInterpretation<A extends AbstractValue<A, C>, C> extends AbstractPartialInterpretation<A, C> {
         private final PartialInterpretation<A, C> opposite;
 
         private OppositeInterpretation(ReasoningAdapter adapter, Concreteness concreteness,
@@ -36,7 +36,7 @@ class OppositeInterpretation<A, C> extends AbstractPartialInterpretation<A, C> {
                 return new OppositeCursor<>(opposite.getAll());
         }
 
-        public static <A1, C1> Factory<A1, C1> of(PartialSymbol<A1, C1> oppositeSymbol) {
+        public static <A1 extends AbstractValue<A1, C1>, 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);
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
index d09684df..47e3ac6a 100644
--- 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
@@ -1,17 +1,18 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.reasoning.translator.opposite;
 
+import tools.refinery.logic.AbstractValue;
 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> {
+public class OppositeRefiner<A extends AbstractValue<A, C>, C> extends AbstractPartialInterpretationRefiner<A, C> {
         private final PartialInterpretationRefiner<A, C> opposite;
 
         protected OppositeRefiner(ReasoningAdapter adapter, PartialSymbol<A, C> partialSymbol,
@@ -26,7 +27,7 @@ public class OppositeRefiner<A, C> extends AbstractPartialInterpretationRefiner<
                 return opposite.merge(oppositeKey, value);
         }
 
-        public static <A1, C1> Factory<A1, C1> of(PartialSymbol<A1, C1> oppositeSymbol) {
+        public static <A1 extends AbstractValue<A1, C1>, C1> Factory<A1, C1> of(PartialSymbol<A1, C1> oppositeSymbol) {
                 return (adapter, partialSymbol) -> new OppositeRefiner<>(adapter, partialSymbol, oppositeSymbol);
         }
 }