53 files changed, 924 insertions, 199 deletions

diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/Cursors.java b/subprojects/store/src/main/java/tools/refinery/store/map/Cursors.java
index 0a94d449..5e69e7af 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/Cursors.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/Cursors.java
@@ -5,6 +5,9 @@
  */
 package tools.refinery.store.map;
 
+import java.util.Iterator;
+import java.util.Map;
+
 public final class Cursors {
     private Cursors() {
         throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
@@ -14,6 +17,18 @@ public final class Cursors {
         return new Empty<>();
     }
 
+        public static <K, V> Cursor<K, V> singleton(K key, V value) {
+                return new Singleton<>(key, value);
+        }
+
+        public static <K, V> Cursor<K, V> of(Iterator<Map.Entry<K, V>> iterator) {
+                return new IteratorBasedCursor<>(iterator);
+        }
+
+        public static <K, V> Cursor<K, V> of(Map<K, V> map) {
+                return of(map.entrySet().iterator());
+        }
+
     private static class Empty<K, V> implements Cursor<K, V> {
         private boolean terminated = false;
 
@@ -38,4 +53,53 @@ public final class Cursors {
             return false;
         }
     }
+
+        private static class Singleton<K, V> implements Cursor<K, V> {
+                private State state = State.INITIAL;
+                private final K key;
+                private final V value;
+
+                public Singleton(K key, V value) {
+                        this.key = key;
+                        this.value = value;
+                }
+
+                @Override
+                public K getKey() {
+                        if (state == State.STARTED) {
+                                return key;
+                        }
+                        return null;
+                }
+
+                @Override
+                public V getValue() {
+                        if (state == State.STARTED) {
+                                return value;
+                        }
+                        return null;
+                }
+
+                @Override
+                public boolean isTerminated() {
+                        return state == State.TERMINATED;
+                }
+
+                @Override
+                public boolean move() {
+                        if (state == State.INITIAL) {
+                                state = State.STARTED;
+                                return true;
+                        }
+                        state = State.TERMINATED;
+                        return false;
+                }
+
+
+                private enum State {
+                        INITIAL,
+                        STARTED,
+                        TERMINATED
+                }
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/IteratorBasedCursor.java b/subprojects/store/src/main/java/tools/refinery/store/map/IteratorBasedCursor.java
new file mode 100644
index 00000000..0ed9b730
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/IteratorBasedCursor.java
@@ -0,0 +1,44 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.map;
+
+import java.util.Iterator;
+import java.util.Map;
+
+public class IteratorBasedCursor<K, V> implements Cursor<K, V> {
+        private final Iterator<Map.Entry<K, V>> iterator;
+        private Map.Entry<K, V> entry;
+        private boolean terminated;
+
+        public IteratorBasedCursor(Iterator<Map.Entry<K, V>> iterator) {
+                this.iterator = iterator;
+        }
+
+        @Override
+        public K getKey() {
+                return entry.getKey();
+        }
+
+        @Override
+        public V getValue() {
+                return entry.getValue();
+        }
+
+        @Override
+        public boolean isTerminated() {
+                return terminated;
+        }
+
+        @Override
+        public boolean move() {
+                if (!terminated && iterator.hasNext()) {
+                        entry = iterator.next();
+                        return true;
+                }
+                terminated = true;
+                return false;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapDeltaImpl.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapDeltaImpl.java
index c19cc817..8be42712 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapDeltaImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/delta/VersionedMapDeltaImpl.java
@@ -5,10 +5,9 @@
  */
 package tools.refinery.store.map.internal.delta;
 
-import java.util.*;
-
 import tools.refinery.store.map.*;
-import tools.refinery.store.map.IteratorAsCursor;
+
+import java.util.*;
 
 public class VersionedMapDeltaImpl<K, V> implements VersionedMap<K, V> {
         protected final VersionedMapStoreDeltaImpl<K, V> store;
@@ -24,7 +23,7 @@ public class VersionedMapDeltaImpl<K, V> implements VersionedMap<K, V> {
                 this.store = store;
                 this.defaultValue = defaultValue;
 
-                current = new HashMap<>();
+                current = new LinkedHashMap<>();
                 if (summarizeChanges) {
                         this.uncommittedStore = new UncommittedDeltaMapStore<>(this);
                 } else {
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/AnyInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/AnyInterpretation.java
index f906b48a..d650bd06 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/AnyInterpretation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/AnyInterpretation.java
@@ -13,4 +13,6 @@ public sealed interface AnyInterpretation permits Interpretation {
         AnySymbol getSymbol();
 
         long getSize();
+
+        int getAdjacentSize(int slot, int node);
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java
index 72f188d3..1b15e4cf 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/Interpretation.java
@@ -19,6 +19,8 @@ public non-sealed interface Interpretation<T> extends AnyInterpretation {
 
         Cursor<Tuple, T> getAll();
 
+        Cursor<Tuple, T> getAdjacent(int slot, int node);
+
         T put(Tuple key, T value);
 
         void putAll(Cursor<Tuple, T> cursor);
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/Model.java b/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
index e2ab72e7..c4ce5207 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/Model.java
@@ -8,11 +8,9 @@ package tools.refinery.store.model;
 import tools.refinery.store.adapter.ModelAdapter;
 import tools.refinery.store.map.Version;
 import tools.refinery.store.map.Versioned;
-import tools.refinery.store.model.internal.VersionedInterpretation;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
 
-import java.util.Map;
 import java.util.Optional;
 
 public interface Model extends Versioned {
@@ -38,4 +36,6 @@ public interface Model extends Versioned {
         void addListener(ModelListener listener);
 
         void removeListener(ModelListener listener);
+
+        void checkCancelled();
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
index 89382b3a..61abf126 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStore.java
@@ -26,6 +26,8 @@ public interface ModelStore {
 
         <T extends ModelStoreAdapter> T getAdapter(Class<T> adapterType);
 
+        void checkCancelled();
+
         static ModelStoreBuilder builder() {
                 return new ModelStoreBuilderImpl();
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreBuilder.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreBuilder.java
index 3a4024b5..9b2b38c3 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreBuilder.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreBuilder.java
@@ -8,12 +8,15 @@ package tools.refinery.store.model;
 import tools.refinery.store.adapter.ModelAdapterBuilder;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.util.CancellationToken;
 
 import java.util.Collection;
 import java.util.List;
 import java.util.Optional;
 
 public interface ModelStoreBuilder {
+        ModelStoreBuilder cancellationToken(CancellationToken cancellationToken);
+
         default ModelStoreBuilder symbols(AnySymbol... symbols) {
                 return symbols(List.of(symbols));
         }
@@ -29,7 +32,9 @@ public interface ModelStoreBuilder {
 
         <T> ModelStoreBuilder symbol(Symbol<T> symbol);
 
-        <T extends ModelAdapterBuilder> ModelStoreBuilder with(T adapterBuilder);
+        ModelStoreBuilder with(ModelAdapterBuilder adapterBuilder);
+
+        ModelStoreBuilder with(ModelStoreConfiguration configuration);
 
         <T extends ModelAdapterBuilder> Optional<T> tryGetAdapter(Class<? extends T> adapterType);
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreConfiguration.java b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreConfiguration.java
new file mode 100644
index 00000000..e94af5f8
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/ModelStoreConfiguration.java
@@ -0,0 +1,11 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.model;
+
+@FunctionalInterface
+public interface ModelStoreConfiguration {
+        void apply(ModelStoreBuilder storeBuilder);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/BaseIndexer.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/BaseIndexer.java
new file mode 100644
index 00000000..3d7f59d7
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/BaseIndexer.java
@@ -0,0 +1,102 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.model.internal;
+
+import org.eclipse.collections.api.factory.Maps;
+import org.eclipse.collections.api.factory.primitive.IntObjectMaps;
+import org.eclipse.collections.api.map.MutableMap;
+import org.eclipse.collections.api.map.primitive.MutableIntObjectMap;
+import tools.refinery.store.map.*;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Set;
+
+class BaseIndexer<T> {
+        private final MutableIntObjectMap<MutableMap<Tuple, T>>[] maps;
+        private final VersionedMap<Tuple, T> versionedMap;
+
+        public BaseIndexer(int arity, VersionedMap<Tuple, T> map) {
+                if (arity < 2) {
+                        throw new IllegalArgumentException("Only arity >= 2 symbols need to be indexed");
+                }
+                // There is no way in Java to create a generic array in a checked way.
+                @SuppressWarnings({"unchecked", "squid:S1905"})
+                var uncheckedMaps = (MutableIntObjectMap<MutableMap<Tuple, T>>[]) new MutableIntObjectMap[arity];
+                maps = uncheckedMaps;
+                for (int i = 0; i < arity; i++) {
+                        maps[i] = IntObjectMaps.mutable.empty();
+                }
+                this.versionedMap = map;
+                if (map != null) {
+                        var cursor = map.getAll();
+                        while (cursor.move()) {
+                                put(cursor.getKey(), cursor.getValue());
+                        }
+                }
+        }
+
+        public void put(Tuple key, T value) {
+                for (int i = 0; i < maps.length; i++) {
+                        var map = maps[i];
+                        int element = key.get(i);
+                        var adjacentTuples = map.getIfAbsentPut(element, Maps.mutable::empty);
+                        adjacentTuples.put(key, value);
+                }
+        }
+
+        public void remove(Tuple key) {
+                for (int i = 0; i < maps.length; i++) {
+                        var map = maps[i];
+                        int element = key.get(i);
+                        var adjacentTuples = map.get(element);
+                        if (adjacentTuples == null) {
+                                continue;
+                        }
+                        adjacentTuples.remove(key);
+                        if (adjacentTuples.isEmpty()) {
+                                map.remove(element);
+                        }
+                }
+        }
+
+        private MutableMap<Tuple, T> getAdjacentMap(int slot, int node) {
+                if (slot < 0 || slot >= maps.length) {
+                        throw new IllegalArgumentException("Invalid index: " + slot);
+                }
+                var map = maps[slot];
+                return map.get(node);
+        }
+
+        public int getAdjacentSize(int slot, int node) {
+                var adjacentTuples = getAdjacentMap(slot, node);
+                if (adjacentTuples == null) {
+                        return 0;
+                }
+                return adjacentTuples.size();
+        }
+
+        public Cursor<Tuple, T> getAdjacent(int slot, int node) {
+                var adjacentTuples = getAdjacentMap(slot, node);
+                if (adjacentTuples == null) {
+                        return Cursors.empty();
+                }
+                return new IndexCursor<>(adjacentTuples, versionedMap);
+        }
+
+        private static class IndexCursor<T> extends IteratorBasedCursor<Tuple, T> {
+                private final Set<AnyVersionedMap> dependingMaps;
+
+                public IndexCursor(MutableMap<Tuple, T> map, VersionedMap<Tuple, T> versionedMap) {
+                        super(map.entrySet().iterator());
+                        dependingMaps = versionedMap == null ? Set.of() : Set.of(versionedMap);
+                }
+
+                @Override
+                public Set<AnyVersionedMap> getDependingMaps() {
+                        return dependingMaps;
+                }
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/IndexedVersionedInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/IndexedVersionedInterpretation.java
new file mode 100644
index 00000000..0be16f77
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/IndexedVersionedInterpretation.java
@@ -0,0 +1,48 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.model.internal;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.VersionedMap;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Objects;
+
+class IndexedVersionedInterpretation<T> extends VersionedInterpretation<T> {
+        private final BaseIndexer<T> indexer;
+
+        public IndexedVersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMap<Tuple, T> map) {
+                super(model, symbol, map);
+                indexer = new BaseIndexer<>(symbol.arity(), map);
+        }
+
+        @Override
+        public Cursor<Tuple, T> getAdjacent(int slot, int node) {
+                return indexer.getAdjacent(slot, node);
+        }
+
+        @Override
+        public int getAdjacentSize(int slot, int node) {
+                return indexer.getAdjacentSize(slot, node);
+        }
+
+        @Override
+        protected boolean shouldNotifyRestoreListeners() {
+                // Always call the {@code valueChanged} method to update the index.
+                return true;
+        }
+
+        @Override
+        protected void valueChanged(Tuple key, T fromValue, T toValue, boolean restoring) {
+                if (Objects.equals(toValue, getSymbol().defaultValue())) {
+                        indexer.remove(key);
+                } else {
+                        indexer.put(key, toValue);
+                }
+                super.valueChanged(key, fromValue, toValue, restoring);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
index 2b12d5a6..d11e431b 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelImpl.java
@@ -13,23 +13,26 @@ import tools.refinery.store.model.*;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.util.CancellationToken;
 
 import java.util.*;
 
 public class ModelImpl implements Model {
-        private final ModelStore store;
+        private final ModelStoreImpl store;
         private Version state;
         private LinkedHashMap<? extends AnySymbol, ? extends VersionedInterpretation<?>> interpretations;
         private final List<ModelAdapter> adapters;
         private final List<ModelListener> listeners = new ArrayList<>();
+        private final CancellationToken cancellationToken;
         private boolean uncommittedChanges;
         private ModelAction pendingAction = ModelAction.NONE;
         private Version restoringToState = null;
 
-        ModelImpl(ModelStore store, Version state, int adapterCount) {
+        ModelImpl(ModelStoreImpl store, Version state, int adapterCount) {
                 this.store = store;
                 this.state = state;
                 adapters = new ArrayList<>(adapterCount);
+                cancellationToken = store.getCancellationToken();
         }
 
         void setInterpretations(LinkedHashMap<? extends AnySymbol, ? extends VersionedInterpretation<?>> interpretations) {
@@ -88,6 +91,7 @@ public class ModelImpl implements Model {
 
         @Override
         public Version commit() {
+                checkCancelled();
                 if (hasPendingAction()) {
                         throw pendingActionError("commit");
                 }
@@ -106,6 +110,7 @@ public class ModelImpl implements Model {
                         Version[] interpretationVersions = new Version[interpretations.size()];
                         int j = 0;
                         for (var interpretationEntry : interpretations.entrySet()) {
+                                checkCancelled();
                                 interpretationVersions[j++] = interpretationEntry.getValue().commit();
                         }
                         ModelVersion modelVersion = new ModelVersion(interpretationVersions);
@@ -125,6 +130,7 @@ public class ModelImpl implements Model {
 
         @Override
         public void restore(Version version) {
+                checkCancelled();
                 if (hasPendingAction()) {
                         throw pendingActionError("restore to %s".formatted(version));
                 }
@@ -140,6 +146,7 @@ public class ModelImpl implements Model {
                         }
                         int j = 0;
                         for (var interpretation : interpretations.values()) {
+                                checkCancelled();
                                 interpretation.restore(ModelVersion.getInternalVersion(version, j++));
                         }
 
@@ -187,4 +194,9 @@ public class ModelImpl implements Model {
         public void removeListener(ModelListener listener) {
                 listeners.remove(listener);
         }
+
+        @Override
+        public void checkCancelled() {
+                cancellationToken.checkCancelled();
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java
index 2bd187a8..53ecde5e 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreBuilderImpl.java
@@ -12,21 +12,37 @@ import tools.refinery.store.map.VersionedMapStoreFactory;
 import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.model.ModelStoreConfiguration;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.util.CancellationToken;
 
 import java.util.*;
 
 public class ModelStoreBuilderImpl implements ModelStoreBuilder {
+        private CancellationToken cancellationToken;
         private final LinkedHashSet<AnySymbol> allSymbols = new LinkedHashSet<>();
         private final LinkedHashMap<SymbolEquivalenceClass<?>, List<AnySymbol>> equivalenceClasses = new LinkedHashMap<>();
         private final List<ModelAdapterBuilder> adapters = new ArrayList<>();
 
         @Override
+        public ModelStoreBuilder cancellationToken(CancellationToken cancellationToken) {
+                if (this.cancellationToken != null) {
+                        throw new IllegalStateException("Cancellation token was already set");
+                }
+                if (cancellationToken == null) {
+                        throw new IllegalStateException("Cancellation token must not be null");
+                }
+                this.cancellationToken = cancellationToken;
+                return this;
+        }
+
+        @Override
         public <T> ModelStoreBuilder symbol(Symbol<T> symbol) {
                 if (!allSymbols.add(symbol)) {
-                        throw new IllegalArgumentException("Symbol %s already added".formatted(symbol));
+                        // No need to add symbol twice.
+                        return this;
                 }
                 var equivalenceClass = new SymbolEquivalenceClass<>(symbol);
                 var symbolsInEquivalenceClass = equivalenceClasses.computeIfAbsent(equivalenceClass,
@@ -36,7 +52,7 @@ public class ModelStoreBuilderImpl implements ModelStoreBuilder {
         }
 
         @Override
-        public <T extends ModelAdapterBuilder> ModelStoreBuilder with(T adapterBuilder) {
+        public ModelStoreBuilder with(ModelAdapterBuilder adapterBuilder) {
                 for (var existingAdapter : adapters) {
                         if (existingAdapter.getClass().equals(adapterBuilder.getClass())) {
                                 throw new IllegalArgumentException("%s adapter was already configured for store builder"
@@ -48,6 +64,12 @@ public class ModelStoreBuilderImpl implements ModelStoreBuilder {
         }
 
         @Override
+        public ModelStoreBuilder with(ModelStoreConfiguration configuration) {
+                configuration.apply(this);
+                return this;
+        }
+
+        @Override
         public <T extends ModelAdapterBuilder> Optional<T> tryGetAdapter(Class<? extends T> adapterType) {
                 return AdapterUtils.tryGetAdapter(adapters, adapterType);
         }
@@ -59,6 +81,7 @@ public class ModelStoreBuilderImpl implements ModelStoreBuilder {
 
         @Override
         public ModelStore build() {
+                // First configure adapters and let them register any symbols we don't know about yet.
                 for (int i = adapters.size() - 1; i >= 0; i--) {
                         adapters.get(i).configure(this);
                 }
@@ -66,7 +89,8 @@ public class ModelStoreBuilderImpl implements ModelStoreBuilder {
                 for (var entry : equivalenceClasses.entrySet()) {
                         createStores(stores, entry.getKey(), entry.getValue());
                 }
-                var modelStore = new ModelStoreImpl(stores, adapters.size());
+                var modelStore = new ModelStoreImpl(stores, adapters.size(), cancellationToken == null ?
+                                CancellationToken.NONE : cancellationToken);
                 for (var adapterBuilder : adapters) {
                         var storeAdapter = adapterBuilder.build(modelStore);
                         modelStore.addAdapter(storeAdapter);
@@ -77,8 +101,8 @@ public class ModelStoreBuilderImpl implements ModelStoreBuilder {
         private <T> void createStores(Map<AnySymbol, VersionedMapStore<Tuple, ?>> stores,
                                                                   SymbolEquivalenceClass<T> equivalenceClass, List<AnySymbol> symbols) {
                 int size = symbols.size();
-                VersionedMapStoreFactory<Tuple,T> mapFactory = VersionedMapStore
-                                .<Tuple,T>builder()
+                VersionedMapStoreFactory<Tuple, T> mapFactory = VersionedMapStore
+                                .<Tuple, T>builder()
                                 .strategy(VersionedMapStoreFactoryBuilder.StoreStrategy.DELTA)
                                 .defaultValue(equivalenceClass.defaultValue())
                                 .build();
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
index a320a618..fd4cc160 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelStoreImpl.java
@@ -14,16 +14,20 @@ import tools.refinery.store.model.ModelDiffCursor;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.util.CancellationToken;
 
 import java.util.*;
 
 public class ModelStoreImpl implements ModelStore {
         private final LinkedHashMap<? extends AnySymbol, ? extends VersionedMapStore<Tuple, ?>> stores;
         private final List<ModelStoreAdapter> adapters;
+        private final CancellationToken cancellationToken;
 
-        ModelStoreImpl(LinkedHashMap<? extends AnySymbol, ? extends VersionedMapStore<Tuple, ?>> stores, int adapterCount) {
+        ModelStoreImpl(LinkedHashMap<? extends AnySymbol, ? extends VersionedMapStore<Tuple, ?>> stores, int adapterCount,
+                                   CancellationToken cancellationToken) {
                 this.stores = stores;
                 adapters = new ArrayList<>(adapterCount);
+                this.cancellationToken = cancellationToken;
         }
 
         @Override
@@ -100,4 +104,13 @@ public class ModelStoreImpl implements ModelStore {
         void addAdapter(ModelStoreAdapter adapter) {
                 adapters.add(adapter);
         }
+
+        @Override
+        public void checkCancelled() {
+                cancellationToken.checkCancelled();
+        }
+
+        CancellationToken getCancellationToken() {
+                return cancellationToken;
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelVersion.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelVersion.java
index f81386f1..c3e52084 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelVersion.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/ModelVersion.java
@@ -11,11 +11,9 @@ import java.util.Arrays;
 
 public class ModelVersion implements Version {
         final Version[] mapVersions;
-        final int hash;
 
         public ModelVersion(Version[] mapVersions) {
                 this.mapVersions = mapVersions;
-                this.hash = Arrays.hashCode(mapVersions);
         }
 
         public static Version getInternalVersion(Version modelVersion, int interpretationIndex) {
@@ -23,16 +21,6 @@ public class ModelVersion implements Version {
         }
 
         @Override
-        public int hashCode() {
-                return hash;
-        }
-
-        @Override
-        public boolean equals(Object obj) {
-                return super.equals(obj);
-        }
-
-        @Override
         public String toString() {
                 return "ModelVersion{" +
                                 "mapVersions=" + Arrays.toString(mapVersions) +
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/NullaryVersionedInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/NullaryVersionedInterpretation.java
new file mode 100644
index 00000000..4a8e6752
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/NullaryVersionedInterpretation.java
@@ -0,0 +1,27 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.model.internal;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.VersionedMap;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+class NullaryVersionedInterpretation<T> extends VersionedInterpretation<T> {
+        public NullaryVersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMap<Tuple, T> map) {
+                super(model, symbol, map);
+        }
+
+        @Override
+        public Cursor<Tuple, T> getAdjacent(int slot, int node) {
+                throw new IllegalArgumentException("Invalid index: " + slot);
+        }
+
+        @Override
+        public int getAdjacentSize(int slot, int node) {
+                throw new IllegalArgumentException("Invalid index: " + slot);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/UnaryVersionedInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/UnaryVersionedInterpretation.java
new file mode 100644
index 00000000..75946680
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/UnaryVersionedInterpretation.java
@@ -0,0 +1,48 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.model.internal;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.Cursors;
+import tools.refinery.store.map.VersionedMap;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Objects;
+
+class UnaryVersionedInterpretation<T> extends VersionedInterpretation<T> {
+        public UnaryVersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMap<Tuple, T> map) {
+                super(model, symbol, map);
+        }
+
+        private void validateSlot(int slot) {
+                if (slot != 0) {
+                        throw new IllegalArgumentException("Invalid index: " + slot);
+                }
+        }
+
+        @Override
+        public Cursor<Tuple, T> getAdjacent(int slot, int node) {
+                validateSlot(slot);
+                var key = Tuple.of(node);
+                var value = get(key);
+                if (Objects.equals(value, getSymbol().defaultValue())) {
+                        return Cursors.empty();
+                }
+                return Cursors.singleton(key, value);
+        }
+
+        @Override
+        public int getAdjacentSize(int slot, int node) {
+                validateSlot(slot);
+                var key = Tuple.of(node);
+                var value = get(key);
+                if (Objects.equals(value, getSymbol().defaultValue())) {
+                        return 0;
+                }
+                return 1;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
index 76e3baea..dcf0ad08 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/model/internal/VersionedInterpretation.java
@@ -16,14 +16,14 @@ import tools.refinery.store.tuple.Tuple;
 import java.util.ArrayList;
 import java.util.List;
 
-public class VersionedInterpretation<T> implements Interpretation<T> {
+public abstract class VersionedInterpretation<T> implements Interpretation<T> {
         private final ModelImpl model;
         private final Symbol<T> symbol;
         private final VersionedMap<Tuple, T> map;
         private final List<InterpretationListener<T>> listeners = new ArrayList<>();
         private final List<InterpretationListener<T>> restoreListeners = new ArrayList<>();
 
-        private VersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMap<Tuple, T> map) {
+        protected VersionedInterpretation(ModelImpl model, Symbol<T> symbol, VersionedMap<Tuple, T> map) {
                 this.model = model;
                 this.symbol = symbol;
                 this.map = map;
@@ -50,6 +50,7 @@ public class VersionedInterpretation<T> implements Interpretation<T> {
                                         .formatted(symbol, symbol.arity()));
                 }
         }
+
         @Override
         public T get(Tuple key) {
                 checkKey(key);
@@ -61,7 +62,7 @@ public class VersionedInterpretation<T> implements Interpretation<T> {
                 return map.getAll();
         }
 
-        private void notifyListeners(Tuple key, T fromValue, T toValue, boolean restoring) {
+        protected void valueChanged(Tuple key, T fromValue, T toValue, boolean restoring) {
                 var listenerList = restoring ? restoreListeners : listeners;
                 int listenerCount = listenerList.size();
                 // Use a for loop instead of a for-each loop to avoid <code>Iterator</code> allocation overhead.
@@ -74,23 +75,21 @@ public class VersionedInterpretation<T> implements Interpretation<T> {
         @Override
         public T put(Tuple key, T value) {
                 checkKey(key);
+                model.checkCancelled();
                 model.markAsChanged();
                 var oldValue = map.put(key, value);
-                notifyListeners(key, oldValue, value, false);
+                valueChanged(key, oldValue, value, false);
                 return oldValue;
         }
 
         @Override
         public void putAll(Cursor<Tuple, T> cursor) {
-                if (listeners.isEmpty()) {
-                        map.putAll(cursor);
-                        return;
-                }
                 model.markAsChanged();
                 if (cursor.getDependingMaps().contains(map)) {
                         List<Tuple> keys = new ArrayList<>();
                         List<T> values = new ArrayList<>();
                         while (cursor.move()) {
+                                model.checkCancelled();
                                 keys.add(cursor.getKey());
                                 values.add(cursor.getValue());
                         }
@@ -114,11 +113,16 @@ public class VersionedInterpretation<T> implements Interpretation<T> {
         Version commit() {
                 return map.commit();
         }
-        void restore(Version state) {
-                if (!restoreListeners.isEmpty()) {
+
+        protected boolean shouldNotifyRestoreListeners() {
+                return !restoreListeners.isEmpty();
+        }
+
+        public void restore(Version state) {
+                if (shouldNotifyRestoreListeners()) {
                         var diffCursor = getDiffCursor(state);
                         while (diffCursor.move()) {
-                                notifyListeners(diffCursor.getKey(), diffCursor.getFromValue(), diffCursor.getToValue(), true);
+                                valueChanged(diffCursor.getKey(), diffCursor.getFromValue(), diffCursor.getToValue(), true);
                         }
                 }
                 map.restore(state);
@@ -142,7 +146,7 @@ public class VersionedInterpretation<T> implements Interpretation<T> {
                 @SuppressWarnings("unchecked")
                 var typedSymbol = (Symbol<T>) symbol;
                 var map = store.createMap();
-                return new VersionedInterpretation<>(model, typedSymbol, map);
+                return of(model, typedSymbol, map);
         }
 
         static <T> VersionedInterpretation<T> of(ModelImpl model, AnySymbol symbol, VersionedMapStore<Tuple, T> store,
@@ -150,6 +154,15 @@ public class VersionedInterpretation<T> implements Interpretation<T> {
                 @SuppressWarnings("unchecked")
                 var typedSymbol = (Symbol<T>) symbol;
                 var map = store.createMap(state);
-                return new VersionedInterpretation<>(model, typedSymbol, map);
+                return of(model, typedSymbol, map);
+        }
+
+        private static <T> VersionedInterpretation<T> of(ModelImpl model, Symbol<T> typedSymbol,
+                                                                                                         VersionedMap<Tuple, T> map) {
+                return switch (typedSymbol.arity()) {
+                        case 0 -> new NullaryVersionedInterpretation<>(model, typedSymbol, map);
+                        case 1 -> new UnaryVersionedInterpretation<>(model, typedSymbol, map);
+                        default -> new IndexedVersionedInterpretation<>(model, typedSymbol, map);
+                };
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/AbstractDomain.java b/subprojects/store/src/main/java/tools/refinery/store/representation/AbstractDomain.java
index 52c740e8..dfdb43bd 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/representation/AbstractDomain.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/AbstractDomain.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.representation;
 
+import java.util.Objects;
 import java.util.Optional;
 
 public non-sealed interface AbstractDomain<A, C> extends AnyAbstractDomain {
@@ -22,7 +23,9 @@ public non-sealed interface AbstractDomain<A, C> extends AnyAbstractDomain {
                 return toConcrete(abstractValue).isPresent();
         }
 
-        boolean isRefinement(A originalValue, A refinedValue);
+        default boolean isRefinement(A originalValue, A refinedValue) {
+                return Objects.equals(commonRefinement(originalValue, refinedValue), refinedValue);
+        }
 
         A commonRefinement(A leftValue, A rightValue);
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/TruthValue.java b/subprojects/store/src/main/java/tools/refinery/store/representation/TruthValue.java
index 40baf9a5..f81ee9a4 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/representation/TruthValue.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/TruthValue.java
@@ -36,6 +36,10 @@ public enum TruthValue {
                 return this != UNKNOWN;
         }
 
+        public boolean isConcrete() {
+                return this == TRUE || this == FALSE;
+        }
+
         public boolean must() {
                 return this == TRUE || this == ERROR;
         }
@@ -55,9 +59,18 @@ public enum TruthValue {
         public TruthValue merge(TruthValue other) {
                 return switch (this) {
                         case TRUE -> other == UNKNOWN || other == TRUE ? TRUE : ERROR;
-                        case FALSE -> other == TruthValue.UNKNOWN || other == TruthValue.FALSE ? FALSE : ERROR;
+                        case FALSE -> other == UNKNOWN || other == FALSE ? FALSE : ERROR;
                         case UNKNOWN -> other;
-                        default -> ERROR;
+                        case ERROR -> ERROR;
+                };
+        }
+
+        public TruthValue join(TruthValue other) {
+                return switch (this) {
+                        case TRUE -> other == ERROR || other == TRUE ? TRUE : UNKNOWN;
+                        case FALSE -> other == ERROR || other == FALSE ? FALSE : UNKNOWN;
+                        case UNKNOWN -> UNKNOWN;
+                        case ERROR -> other;
                 };
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/TruthValueDomain.java b/subprojects/store/src/main/java/tools/refinery/store/representation/TruthValueDomain.java
index 89f8dd19..61696dca 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/representation/TruthValueDomain.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/TruthValueDomain.java
@@ -7,6 +7,8 @@ package tools.refinery.store.representation;
 
 import java.util.Optional;
 
+// Singleton pattern, because there is only one domain for truth values.
+@SuppressWarnings("squid:S6548")
 public final class TruthValueDomain implements AbstractDomain<TruthValue, Boolean> {
         public static final TruthValueDomain INSTANCE = new TruthValueDomain();
 
@@ -15,51 +17,50 @@ public final class TruthValueDomain implements AbstractDomain<TruthValue, Boolea
 
         @Override
         public Class<TruthValue> abstractType() {
-                return null;
+                return TruthValue.class;
         }
 
         @Override
         public Class<Boolean> concreteType() {
-                return null;
+                return Boolean.class;
         }
 
         @Override
         public TruthValue toAbstract(Boolean concreteValue) {
-                return null;
+                return TruthValue.toTruthValue(concreteValue);
         }
 
         @Override
         public Optional<Boolean> toConcrete(TruthValue abstractValue) {
-                return Optional.empty();
+                return switch (abstractValue) {
+                        case TRUE -> Optional.of(true);
+                        case FALSE -> Optional.of(false);
+                        default -> Optional.empty();
+                };
         }
 
         @Override
         public boolean isConcrete(TruthValue abstractValue) {
-                return AbstractDomain.super.isConcrete(abstractValue);
-        }
-
-        @Override
-        public boolean isRefinement(TruthValue originalValue, TruthValue refinedValue) {
-                return false;
+                return abstractValue.isConcrete();
         }
 
         @Override
         public TruthValue commonRefinement(TruthValue leftValue, TruthValue rightValue) {
-                return null;
+                return leftValue.merge(rightValue);
         }
 
         @Override
         public TruthValue commonAncestor(TruthValue leftValue, TruthValue rightValue) {
-                return null;
+                return leftValue.join(rightValue);
         }
 
         @Override
         public TruthValue unknown() {
-                return null;
+                return TruthValue.UNKNOWN;
         }
 
         @Override
         public boolean isError(TruthValue abstractValue) {
-                return false;
+                return !abstractValue.isConsistent();
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityDomain.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityDomain.java
new file mode 100644
index 00000000..7ae2d935
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityDomain.java
@@ -0,0 +1,68 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.representation.cardinality;
+
+import tools.refinery.store.representation.AbstractDomain;
+
+import java.util.Optional;
+
+// Singleton pattern, because there is only one domain for truth values.
+@SuppressWarnings("squid:S6548")
+public class CardinalityDomain implements AbstractDomain<CardinalityInterval, Integer> {
+        public static final CardinalityDomain INSTANCE = new CardinalityDomain();
+
+        private CardinalityDomain() {
+        }
+
+        @Override
+        public Class<CardinalityInterval> abstractType() {
+                return CardinalityInterval.class;
+        }
+
+        @Override
+        public Class<Integer> concreteType() {
+                return Integer.class;
+        }
+
+        @Override
+        public CardinalityInterval toAbstract(Integer concreteValue) {
+                return CardinalityIntervals.exactly(concreteValue);
+        }
+
+        @Override
+        public Optional<Integer> toConcrete(CardinalityInterval abstractValue) {
+                return isConcrete(abstractValue) ? Optional.of(abstractValue.lowerBound()) : Optional.empty();
+        }
+
+        @Override
+        public boolean isConcrete(CardinalityInterval abstractValue) {
+                if (!(abstractValue instanceof NonEmptyCardinalityInterval nonEmptyValue) ||
+                                !((nonEmptyValue.upperBound()) instanceof FiniteUpperCardinality finiteUpperCardinality)) {
+                        return false;
+                }
+                return nonEmptyValue.lowerBound() == finiteUpperCardinality.finiteUpperBound();
+        }
+
+        @Override
+        public CardinalityInterval commonRefinement(CardinalityInterval leftValue, CardinalityInterval rightValue) {
+                return leftValue.meet(rightValue);
+        }
+
+        @Override
+        public CardinalityInterval commonAncestor(CardinalityInterval leftValue, CardinalityInterval rightValue) {
+                return leftValue.join(rightValue);
+        }
+
+        @Override
+        public CardinalityInterval unknown() {
+                return CardinalityIntervals.SET;
+        }
+
+        @Override
+        public boolean isError(CardinalityInterval abstractValue) {
+                return abstractValue.isEmpty();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityInterval.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityInterval.java
index 704ca2fc..b20c685a 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityInterval.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityInterval.java
@@ -18,6 +18,8 @@ public sealed interface CardinalityInterval permits NonEmptyCardinalityInterval,
 
         CardinalityInterval add(CardinalityInterval other);
 
+        CardinalityInterval take(int count);
+
         CardinalityInterval multiply(CardinalityInterval other);
 
         CardinalityInterval meet(CardinalityInterval other);
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityIntervals.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityIntervals.java
index ad16a3e8..855fd248 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityIntervals.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/CardinalityIntervals.java
@@ -30,7 +30,7 @@ public final class CardinalityIntervals {
         }
 
         public static CardinalityInterval between(int lowerBound, int upperBound) {
-                return between(lowerBound, UpperCardinalities.valueOf(upperBound));
+                return between(lowerBound, UpperCardinalities.atMost(upperBound));
         }
 
         public static CardinalityInterval atMost(UpperCardinality upperBound) {
@@ -38,7 +38,7 @@ public final class CardinalityIntervals {
         }
 
         public static CardinalityInterval atMost(int upperBound) {
-                return atMost(UpperCardinalities.valueOf(upperBound));
+                return atMost(UpperCardinalities.atMost(upperBound));
         }
 
         public static CardinalityInterval atLeast(int lowerBound) {
@@ -46,6 +46,6 @@ public final class CardinalityIntervals {
         }
 
         public static CardinalityInterval exactly(int lowerBound) {
-                return new NonEmptyCardinalityInterval(lowerBound, UpperCardinalities.valueOf(lowerBound));
+                return new NonEmptyCardinalityInterval(lowerBound, UpperCardinalities.atMost(lowerBound));
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/EmptyCardinalityInterval.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/EmptyCardinalityInterval.java
index 49911c29..9e371e21 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/EmptyCardinalityInterval.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/EmptyCardinalityInterval.java
@@ -5,6 +5,8 @@
  */
 package tools.refinery.store.representation.cardinality;
 
+// Singleton implementation, because there is only a single empty interval.
+@SuppressWarnings("squid:S6548")
 public final class EmptyCardinalityInterval implements CardinalityInterval {
         static final EmptyCardinalityInterval INSTANCE = new EmptyCardinalityInterval();
 
@@ -43,6 +45,11 @@ public final class EmptyCardinalityInterval implements CardinalityInterval {
         }
 
         @Override
+        public CardinalityInterval take(int count) {
+                return this;
+        }
+
+        @Override
         public CardinalityInterval multiply(CardinalityInterval other) {
                 return this;
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/FiniteUpperCardinality.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/FiniteUpperCardinality.java
index 82afdbbc..b63a8637 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/FiniteUpperCardinality.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/FiniteUpperCardinality.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.representation.cardinality;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.function.IntBinaryOperator;
 
@@ -22,6 +23,15 @@ public record FiniteUpperCardinality(int finiteUpperBound) implements UpperCardi
         }
 
         @Override
+        @Nullable
+        public UpperCardinality take(int count) {
+                if (finiteUpperBound < count) {
+                        return null;
+                }
+                return new FiniteUpperCardinality(finiteUpperBound - count);
+        }
+
+        @Override
         public UpperCardinality multiply(UpperCardinality other) {
                 return lift(other, (a, b) -> a * b);
         }
@@ -49,7 +59,7 @@ public record FiniteUpperCardinality(int finiteUpperBound) implements UpperCardi
 
         private UpperCardinality lift(@NotNull UpperCardinality other, IntBinaryOperator operator) {
                 if (other instanceof FiniteUpperCardinality finiteUpperCardinality) {
-                        return UpperCardinalities.valueOf(operator.applyAsInt(finiteUpperBound,
+                        return UpperCardinalities.atMost(operator.applyAsInt(finiteUpperBound,
                                         finiteUpperCardinality.finiteUpperBound));
                 }
                 if (other instanceof UnboundedUpperCardinality) {
@@ -57,4 +67,17 @@ public record FiniteUpperCardinality(int finiteUpperBound) implements UpperCardi
                 }
                 throw new IllegalArgumentException("Unknown UpperCardinality: " + other);
         }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                FiniteUpperCardinality that = (FiniteUpperCardinality) o;
+                return finiteUpperBound == that.finiteUpperBound;
+        }
+
+        @Override
+        public int hashCode() {
+                return finiteUpperBound;
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/NonEmptyCardinalityInterval.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/NonEmptyCardinalityInterval.java
index 38bd53bf..6bd66df7 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/NonEmptyCardinalityInterval.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/NonEmptyCardinalityInterval.java
@@ -5,6 +5,7 @@
  */
 package tools.refinery.store.representation.cardinality;
 
+import java.util.Objects;
 import java.util.function.BinaryOperator;
 import java.util.function.IntBinaryOperator;
 
@@ -53,6 +54,16 @@ public record NonEmptyCardinalityInterval(int lowerBound, UpperCardinality upper
                 return lift(other, Math::min, UpperCardinality::max, this);
         }
 
+        @Override
+        public CardinalityInterval take(int count) {
+                int newLowerBound = Math.max(lowerBound - count, 0);
+                var newUpperBound = upperBound.take(count);
+                if (newUpperBound == null) {
+                        return CardinalityIntervals.ERROR;
+                }
+                return CardinalityIntervals.between(newLowerBound, newUpperBound);
+        }
+
         private CardinalityInterval lift(CardinalityInterval other, IntBinaryOperator lowerOperator,
                                                                          BinaryOperator<UpperCardinality> upperOperator,
                                                                          CardinalityInterval whenEmpty) {
@@ -73,7 +84,23 @@ public record NonEmptyCardinalityInterval(int lowerBound, UpperCardinality upper
 
         @Override
         public String toString() {
-                var closeBracket = upperBound instanceof UnboundedUpperCardinality ? ")" : "]";
-                return "[%d..%s%s".formatted(lowerBound, upperBound, closeBracket);
+                if (upperBound instanceof FiniteUpperCardinality finiteUpperCardinality &&
+                                finiteUpperCardinality.finiteUpperBound() == lowerBound) {
+                        return "[%d]".formatted(lowerBound);
+                }
+                return "[%d..%s]".formatted(lowerBound, upperBound);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                NonEmptyCardinalityInterval that = (NonEmptyCardinalityInterval) o;
+                return lowerBound == that.lowerBound && Objects.equals(upperBound, that.upperBound);
+        }
+
+        @Override
+        public int hashCode() {
+                return lowerBound * 31 + upperBound.hashCode();
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UnboundedUpperCardinality.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UnboundedUpperCardinality.java
index a5634020..03c701ae 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UnboundedUpperCardinality.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UnboundedUpperCardinality.java
@@ -7,6 +7,8 @@ package tools.refinery.store.representation.cardinality;
 
 import org.jetbrains.annotations.NotNull;
 
+// Singleton implementation, because there is only a single countable infinity.
+@SuppressWarnings("squid:S6548")
 public final class UnboundedUpperCardinality implements UpperCardinality {
         static final UnboundedUpperCardinality INSTANCE = new UnboundedUpperCardinality();
 
@@ -20,10 +22,17 @@ public final class UnboundedUpperCardinality implements UpperCardinality {
         }
 
         @Override
+        public UpperCardinality take(int count) {
+                return this;
+        }
+
+        @Override
         public UpperCardinality multiply(UpperCardinality other) {
                 return this;
         }
 
+        // This should always be greater than any finite cardinality.
+        @SuppressWarnings("ComparatorMethodParameterNotUsed")
         @Override
         public int compareTo(@NotNull UpperCardinality upperCardinality) {
                 if (upperCardinality instanceof FiniteUpperCardinality) {
@@ -44,4 +53,14 @@ public final class UnboundedUpperCardinality implements UpperCardinality {
         public String toString() {
                 return "*";
         }
+
+        @Override
+        public boolean equals(Object obj) {
+                return this == obj || (obj != null && getClass() == obj.getClass());
+        }
+
+        @Override
+        public int hashCode() {
+                return -1;
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UpperCardinalities.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UpperCardinalities.java
index 1e18dde0..17d1b292 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UpperCardinalities.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UpperCardinalities.java
@@ -26,7 +26,7 @@ public final class UpperCardinalities {
                 throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
         }
 
-        public static UpperCardinality valueOf(int upperBound) {
+        public static UpperCardinality atMost(int upperBound) {
                 if (upperBound < 0) {
                         return UNBOUNDED;
                 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UpperCardinality.java b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UpperCardinality.java
index 5dbaa922..3f0db028 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UpperCardinality.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/cardinality/UpperCardinality.java
@@ -5,6 +5,8 @@
  */
 package tools.refinery.store.representation.cardinality;
 
+import org.jetbrains.annotations.Nullable;
+
 public sealed interface UpperCardinality extends Comparable<UpperCardinality> permits FiniteUpperCardinality,
                 UnboundedUpperCardinality {
         default UpperCardinality min(UpperCardinality other) {
@@ -17,11 +19,14 @@ public sealed interface UpperCardinality extends Comparable<UpperCardinality> pe
 
         UpperCardinality add(UpperCardinality other);
 
+        @Nullable
+        UpperCardinality take(int count);
+
         UpperCardinality multiply(UpperCardinality other);
 
         int compareToInt(int value);
 
         static UpperCardinality of(int upperBound) {
-                return UpperCardinalities.valueOf(upperBound);
+                return UpperCardinalities.atMost(upperBound);
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCodeCalculatorFactory.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCodeCalculatorFactory.java
index 04e17a13..809205e4 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCodeCalculatorFactory.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCodeCalculatorFactory.java
@@ -7,9 +7,10 @@ package tools.refinery.store.statecoding;
 
 import org.eclipse.collections.api.set.primitive.IntSet;
 import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.Model;
 
 import java.util.List;
 
 public interface StateCodeCalculatorFactory {
-        StateCodeCalculator create(List<? extends Interpretation<?>> interpretations, IntSet individuals);
+        StateCodeCalculator create(Model model, List<? extends Interpretation<?>> interpretations, IntSet individuals);
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderAdapter.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderAdapter.java
index 8cfd24d5..cb73d27e 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderAdapter.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderAdapter.java
@@ -17,7 +17,7 @@ public interface StateCoderAdapter extends ModelAdapter {
                 return calculateStateCode().objectCode();
         }
 
-        static StateCoderBuilderImpl builder() {
+        static StateCoderBuilder builder() {
                 return new StateCoderBuilderImpl();
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateEquivalenceChecker.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateEquivalenceChecker.java
index 3fd8c8d8..0f0023ed 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateEquivalenceChecker.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateEquivalenceChecker.java
@@ -6,7 +6,7 @@
 package tools.refinery.store.statecoding;
 
 import org.eclipse.collections.api.set.primitive.IntSet;
-import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.AnyInterpretation;
 
 import java.util.List;
 
@@ -16,9 +16,6 @@ public interface StateEquivalenceChecker {
         }
 
         EquivalenceResult constructMorphism(
-                        IntSet individuals,
-                        List<? extends Interpretation<?>> interpretations1,
-                        ObjectCode code1, List<?
-                        extends Interpretation<?>> interpretations2,
-                        ObjectCode code2);
+                        IntSet individuals, List<? extends AnyInterpretation> interpretations1, ObjectCode code1,
+                        List<? extends AnyInterpretation> interpretations2, ObjectCode code2);
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderBuilderImpl.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderBuilderImpl.java
index 05b47c52..eed591e7 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderBuilderImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderBuilderImpl.java
@@ -5,61 +5,61 @@
  */
 package tools.refinery.store.statecoding.internal;
 
-import org.eclipse.collections.impl.set.mutable.primitive.IntHashSet;
+import org.eclipse.collections.api.factory.primitive.IntSets;
+import org.eclipse.collections.api.set.primitive.MutableIntSet;
+import tools.refinery.store.adapter.AbstractModelAdapterBuilder;
 import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
-import tools.refinery.store.statecoding.*;
+import tools.refinery.store.statecoding.StateCodeCalculatorFactory;
+import tools.refinery.store.statecoding.StateCoderBuilder;
+import tools.refinery.store.statecoding.StateCoderStoreAdapter;
+import tools.refinery.store.statecoding.StateEquivalenceChecker;
 import tools.refinery.store.statecoding.neighbourhood.NeighbourhoodCalculator;
 import tools.refinery.store.statecoding.stateequivalence.StateEquivalenceCheckerImpl;
 import tools.refinery.store.tuple.Tuple1;
 
-import java.util.*;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
 
-public class StateCoderBuilderImpl implements StateCoderBuilder {
-        Set<AnySymbol> excluded = new HashSet<>();
-        IntHashSet individuals = new IntHashSet();
-
-        StateCodeCalculatorFactory calculator = NeighbourhoodCalculator::new;
-        StateEquivalenceChecker checker = new StateEquivalenceCheckerImpl();
+public class StateCoderBuilderImpl extends AbstractModelAdapterBuilder<StateCoderStoreAdapter>
+                implements StateCoderBuilder {
+        private final Set<AnySymbol> excluded = new HashSet<>();
+        private final MutableIntSet individuals = IntSets.mutable.empty();
+        private StateCodeCalculatorFactory calculator = NeighbourhoodCalculator::new;
+        private StateEquivalenceChecker checker = new StateEquivalenceCheckerImpl();
 
         @Override
         public StateCoderBuilder exclude(AnySymbol symbol) {
+                checkNotConfigured();
                 excluded.add(symbol);
                 return this;
         }
 
         @Override
         public StateCoderBuilder individual(Tuple1 tuple) {
+                checkNotConfigured();
                 individuals.add(tuple.get(0));
                 return this;
         }
 
         @Override
         public StateCoderBuilder stateEquivalenceChecker(StateEquivalenceChecker stateEquivalenceChecker) {
+                checkNotConfigured();
                 this.checker = stateEquivalenceChecker;
                 return this;
         }
 
         @Override
         public StateCoderBuilder stateCodeCalculatorFactory(StateCodeCalculatorFactory codeCalculatorFactory) {
+                checkNotConfigured();
                 this.calculator = codeCalculatorFactory;
                 return this;
         }
 
         @Override
-        public boolean isConfigured() {
-                return true;
-        }
-
-        @Override
-        public void configure(ModelStoreBuilder storeBuilder) {
-                // It does not modify the build process
-        }
-
-        @Override
-        public StateCoderStoreAdapter build(ModelStore store) {
+        protected StateCoderStoreAdapter doBuild(ModelStore store) {
                 Set<Symbol<?>> symbols = new LinkedHashSet<>();
                 for (AnySymbol symbol : store.getSymbols()) {
                         if (!excluded.contains(symbol) && (symbol instanceof Symbol<?> typed)) {
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderStoreAdapterImpl.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderStoreAdapterImpl.java
index 89586bfb..2cb6f3c1 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderStoreAdapterImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/internal/StateCoderStoreAdapterImpl.java
@@ -68,7 +68,7 @@ public class StateCoderStoreAdapterImpl implements StateCoderStoreAdapter {
         @Override
         public StateCoderAdapter createModelAdapter(Model model) {
                 var interpretations = symbols.stream().map(model::getInterpretation).toList();
-                var coder = codeCalculatorFactory.create(interpretations, individuals);
+                var coder = codeCalculatorFactory.create(model, interpretations, individuals);
                 return new StateCoderAdapterImpl(this, coder, model);
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/AbstractNeighbourhoodCalculator.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/AbstractNeighbourhoodCalculator.java
index 0a40a19d..4cef6786 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/AbstractNeighbourhoodCalculator.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/AbstractNeighbourhoodCalculator.java
@@ -5,9 +5,12 @@
  */
 package tools.refinery.store.statecoding.neighbourhood;
 
+import org.eclipse.collections.api.factory.primitive.IntLongMaps;
+import org.eclipse.collections.api.map.primitive.MutableIntLongMap;
 import org.eclipse.collections.api.set.primitive.IntSet;
-import org.eclipse.collections.impl.map.mutable.primitive.IntLongHashMap;
+import tools.refinery.store.model.AnyInterpretation;
 import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.Model;
 import tools.refinery.store.statecoding.ObjectCode;
 import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.tuple.Tuple0;
@@ -15,25 +18,28 @@ import tools.refinery.store.tuple.Tuple0;
 import java.util.*;
 
 public abstract class AbstractNeighbourhoodCalculator {
-        protected final List<Interpretation<?>> nullImpactValues;
-        protected final LinkedHashMap<Interpretation<?>, long[]> impactValues;
-        protected final IntLongHashMap individualHashValues;
+        protected final Model model;
+        protected final List<AnyInterpretation> nullImpactValues;
+        protected final LinkedHashMap<AnyInterpretation, long[]> impactValues;
+        protected final MutableIntLongMap individualHashValues = IntLongMaps.mutable.empty();
 
         protected static final long PRIME = 31;
 
-        protected AbstractNeighbourhoodCalculator(List<? extends Interpretation<?>> interpretations, IntSet individuals) {
+        protected AbstractNeighbourhoodCalculator(Model model, List<? extends AnyInterpretation> interpretations,
+                                                                                          IntSet individuals) {
+                this.model = model;
                 this.nullImpactValues = new ArrayList<>();
                 this.impactValues = new LinkedHashMap<>();
+                // Random isn't used for cryptographical purposes but just to assign distinguishable identifiers to symbols.
                 @SuppressWarnings("squid:S2245")
                 Random random = new Random(1);
 
-                individualHashValues = new IntLongHashMap();
                 var individualsInOrder = individuals.toSortedList(Integer::compare);
                 for(int i = 0; i<individualsInOrder.size(); i++) {
                         individualHashValues.put(individualsInOrder.get(i), random.nextLong());
                 }
 
-                for (Interpretation<?> interpretation : interpretations) {
+                for (AnyInterpretation interpretation : interpretations) {
                         int arity = interpretation.getSymbol().arity();
                         if (arity == 0) {
                                 nullImpactValues.add(interpretation);
@@ -86,7 +92,7 @@ public abstract class AbstractNeighbourhoodCalculator {
         protected long calculateModelCode(long lastSum) {
                 long result = 0;
                 for (var nullImpactValue : nullImpactValues) {
-                        result = result * PRIME + Objects.hashCode(nullImpactValue.get(Tuple0.INSTANCE));
+                        result = result * PRIME + Objects.hashCode(((Interpretation<?>) nullImpactValue).get(Tuple0.INSTANCE));
                 }
                 result += lastSum;
                 return result;
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/LazyNeighbourhoodCalculator.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/LazyNeighbourhoodCalculator.java
index 2ffbef5e..04335141 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/LazyNeighbourhoodCalculator.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/LazyNeighbourhoodCalculator.java
@@ -5,11 +5,14 @@
  */
 package tools.refinery.store.statecoding.neighbourhood;
 
+import org.eclipse.collections.api.factory.primitive.LongIntMaps;
 import org.eclipse.collections.api.map.primitive.LongIntMap;
+import org.eclipse.collections.api.map.primitive.MutableLongIntMap;
 import org.eclipse.collections.api.set.primitive.IntSet;
-import org.eclipse.collections.impl.map.mutable.primitive.LongIntHashMap;
 import tools.refinery.store.map.Cursor;
+import tools.refinery.store.model.AnyInterpretation;
 import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.Model;
 import tools.refinery.store.statecoding.StateCodeCalculator;
 import tools.refinery.store.statecoding.StateCoderResult;
 import tools.refinery.store.tuple.Tuple;
@@ -17,13 +20,14 @@ import tools.refinery.store.tuple.Tuple;
 import java.util.List;
 
 public class LazyNeighbourhoodCalculator extends AbstractNeighbourhoodCalculator implements StateCodeCalculator {
-        public LazyNeighbourhoodCalculator(List<? extends Interpretation<?>> interpretations, IntSet individuals) {
-                super(interpretations, individuals);
+        public LazyNeighbourhoodCalculator(Model model, List<? extends AnyInterpretation> interpretations,
+                                                                           IntSet individuals) {
+                super(model, interpretations, individuals);
         }
 
         public StateCoderResult calculateCodes() {
                 ObjectCodeImpl previousObjectCode = new ObjectCodeImpl();
-                LongIntHashMap prevHash2Amount = new LongIntHashMap();
+                MutableLongIntMap prevHash2Amount = LongIntMaps.mutable.empty();
 
                 long lastSum;
                 // All hash code is 0, except to the individuals.
@@ -42,7 +46,7 @@ public class LazyNeighbourhoodCalculator extends AbstractNeighbourhoodCalculator
                         }
                         constructNextObjectCodes(previousObjectCode, nextObjectCode, prevHash2Amount);
 
-                        LongIntHashMap nextHash2Amount = new LongIntHashMap();
+                        MutableLongIntMap nextHash2Amount = LongIntMaps.mutable.empty();
                         lastSum = calculateLastSum(previousObjectCode, nextObjectCode, prevHash2Amount, nextHash2Amount);
 
                         int nextSize = nextHash2Amount.size();
@@ -60,7 +64,7 @@ public class LazyNeighbourhoodCalculator extends AbstractNeighbourhoodCalculator
         }
 
         private long calculateLastSum(ObjectCodeImpl previous, ObjectCodeImpl next, LongIntMap hash2Amount,
-                                                                  LongIntHashMap nextHash2Amount) {
+                                                                  MutableLongIntMap nextHash2Amount) {
                 long lastSum = 0;
                 for (int i = 0; i < next.getSize(); i++) {
                         final long hash;
@@ -84,7 +88,7 @@ public class LazyNeighbourhoodCalculator extends AbstractNeighbourhoodCalculator
 
         private void constructNextObjectCodes(ObjectCodeImpl previous, ObjectCodeImpl next, LongIntMap hash2Amount) {
                 for (var impactValueEntry : this.impactValues.entrySet()) {
-                        Interpretation<?> interpretation = impactValueEntry.getKey();
+                        Interpretation<?> interpretation = (Interpretation<?>) impactValueEntry.getKey();
                         var cursor = interpretation.getAll();
                         int arity = interpretation.getSymbol().arity();
                         long[] impactValue = impactValueEntry.getValue();
@@ -114,7 +118,8 @@ public class LazyNeighbourhoodCalculator extends AbstractNeighbourhoodCalculator
                 return amount == 1;
         }
 
-        private void lazyImpactCalculation1(LongIntMap hash2Amount, ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues, Cursor<Tuple, ?> cursor) {
+        private void lazyImpactCalculation1(LongIntMap hash2Amount, ObjectCodeImpl previous, ObjectCodeImpl next,
+                                                                                long[] impactValues, Cursor<Tuple, ?> cursor) {
 
                 Tuple tuple = cursor.getKey();
                 int o = tuple.get(0);
@@ -129,7 +134,8 @@ public class LazyNeighbourhoodCalculator extends AbstractNeighbourhoodCalculator
                 }
         }
 
-        private void lazyImpactCalculation2(LongIntMap hash2Amount, ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues, Cursor<Tuple, ?> cursor) {
+        private void lazyImpactCalculation2(LongIntMap hash2Amount, ObjectCodeImpl previous, ObjectCodeImpl next,
+                                                                                long[] impactValues, Cursor<Tuple, ?> cursor) {
                 final Tuple tuple = cursor.getKey();
                 final int o1 = tuple.get(0);
                 final int o2 = tuple.get(1);
@@ -155,7 +161,8 @@ public class LazyNeighbourhoodCalculator extends AbstractNeighbourhoodCalculator
                 }
         }
 
-        private void lazyImpactCalculationN(LongIntMap hash2Amount, ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues, Cursor<Tuple, ?> cursor) {
+        private void lazyImpactCalculationN(LongIntMap hash2Amount, ObjectCodeImpl previous, ObjectCodeImpl next,
+                                                                                long[] impactValues, Cursor<Tuple, ?> cursor) {
                 final Tuple tuple = cursor.getKey();
 
                 final boolean[] uniques = new boolean[tuple.getSize()];
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/NeighbourhoodCalculator.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/NeighbourhoodCalculator.java
index 5b3e5ea3..5e6de53b 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/NeighbourhoodCalculator.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/NeighbourhoodCalculator.java
@@ -8,6 +8,7 @@ package tools.refinery.store.statecoding.neighbourhood;
 import org.eclipse.collections.api.set.primitive.IntSet;
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.Model;
 import tools.refinery.store.statecoding.ObjectCode;
 import tools.refinery.store.statecoding.StateCodeCalculator;
 import tools.refinery.store.statecoding.StateCoderResult;
@@ -18,21 +19,27 @@ import java.util.List;
 import java.util.Objects;
 
 public class NeighbourhoodCalculator extends AbstractNeighbourhoodCalculator implements StateCodeCalculator {
-        public NeighbourhoodCalculator(List<? extends Interpretation<?>> interpretations, IntSet individuals) {
-                super(interpretations, individuals);
+        private ObjectCodeImpl previousObjectCode = new ObjectCodeImpl();
+        private ObjectCodeImpl nextObjectCode = new ObjectCodeImpl();
+
+        public NeighbourhoodCalculator(Model model, List<? extends Interpretation<?>> interpretations, IntSet individuals) {
+                super(model, interpretations, individuals);
         }
 
         public StateCoderResult calculateCodes() {
-                ObjectCodeImpl previousObjectCode = new ObjectCodeImpl();
+                model.checkCancelled();
+                previousObjectCode.clear();
+                nextObjectCode.clear();
                 initializeWithIndividuals(previousObjectCode);
 
                 int rounds = 0;
                 do {
-                        final ObjectCodeImpl nextObjectCode = rounds == 0 ? new ObjectCodeImpl() :
-                                        new ObjectCodeImpl(previousObjectCode.getSize());
-
+                        model.checkCancelled();
                         constructNextObjectCodes(previousObjectCode, nextObjectCode);
+                        var tempObjectCode = previousObjectCode;
                         previousObjectCode = nextObjectCode;
+                        nextObjectCode = tempObjectCode;
+                        nextObjectCode.clear();
                         rounds++;
                 } while (rounds <= 7 && rounds <= previousObjectCode.getEffectiveSize());
 
@@ -43,7 +50,7 @@ public class NeighbourhoodCalculator extends AbstractNeighbourhoodCalculator imp
         private long calculateLastSum(ObjectCode codes) {
                 long result = 0;
                 for (var nullImpactValue : nullImpactValues) {
-                        result = result * 31 + Objects.hashCode(nullImpactValue.get(Tuple0.INSTANCE));
+                        result = result * PRIME + Objects.hashCode(((Interpretation<?>) nullImpactValue).get(Tuple0.INSTANCE));
                 }
 
                 for (int i = 0; i < codes.getSize(); i++) {
@@ -56,7 +63,8 @@ public class NeighbourhoodCalculator extends AbstractNeighbourhoodCalculator imp
 
         private void constructNextObjectCodes(ObjectCodeImpl previous, ObjectCodeImpl next) {
                 for (var impactValueEntry : this.impactValues.entrySet()) {
-                        Interpretation<?> interpretation = impactValueEntry.getKey();
+                        model.checkCancelled();
+                        Interpretation<?> interpretation = (Interpretation<?>) impactValueEntry.getKey();
                         var cursor = interpretation.getAll();
                         int arity = interpretation.getSymbol().arity();
                         long[] impactValue = impactValueEntry.getValue();
@@ -78,7 +86,8 @@ public class NeighbourhoodCalculator extends AbstractNeighbourhoodCalculator imp
         }
 
 
-        private void impactCalculation1(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues, Cursor<Tuple, ?> cursor) {
+        private void impactCalculation1(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues,
+                                                                        Cursor<Tuple, ?> cursor) {
 
                 Tuple tuple = cursor.getKey();
                 int o = tuple.get(0);
@@ -87,7 +96,8 @@ public class NeighbourhoodCalculator extends AbstractNeighbourhoodCalculator imp
                 addHash(next, o, impactValues[0], tupleHash);
         }
 
-        private void impactCalculation2(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues, Cursor<Tuple, ?> cursor) {
+        private void impactCalculation2(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues,
+                                                                        Cursor<Tuple, ?> cursor) {
                 final Tuple tuple = cursor.getKey();
                 final int o1 = tuple.get(0);
                 final int o2 = tuple.get(1);
@@ -99,7 +109,8 @@ public class NeighbourhoodCalculator extends AbstractNeighbourhoodCalculator imp
                 addHash(next, o2, impactValues[1], tupleHash);
         }
 
-        private void impactCalculationN(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues, Cursor<Tuple, ?> cursor) {
+        private void impactCalculationN(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues,
+                                                                        Cursor<Tuple, ?> cursor) {
                 final Tuple tuple = cursor.getKey();
 
                 Object value = cursor.getValue();
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/ObjectCodeImpl.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/ObjectCodeImpl.java
index 0cd7ff58..422e1d73 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/ObjectCodeImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/ObjectCodeImpl.java
@@ -32,6 +32,13 @@ public class ObjectCodeImpl implements ObjectCode {
                 effectiveSize = copy.effectiveSize;
         }
 
+        public void clear() {
+                effectiveSize = 0;
+                for (int i = 0; i < size; i++) {
+                        vector[i] = 0;
+                }
+        }
+
         public void ensureSize(int object) {
                 if (object >= size) {
                         size = object + 1;
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/CombinationNodePairing.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/CombinationNodePairing.java
index decff1d5..0682e1a4 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/CombinationNodePairing.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/CombinationNodePairing.java
@@ -8,18 +8,14 @@ package tools.refinery.store.statecoding.stateequivalence;
 import org.eclipse.collections.api.factory.primitive.IntIntMaps;
 import org.eclipse.collections.api.map.primitive.IntIntMap;
 import org.eclipse.collections.api.set.primitive.IntSet;
-import org.eclipse.collections.impl.list.Interval;
-import org.eclipse.collections.impl.set.mutable.primitive.IntHashSet;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
+import java.util.*;
 
 public class CombinationNodePairing implements NodePairing {
         private final int[] left;
         private final int[] right;
 
-        CombinationNodePairing(IntSet left, IntHashSet right) {
+        CombinationNodePairing(IntSet left, IntSet right) {
                 this.left = left.toArray();
                 this.right = right.toArray();
 
@@ -32,59 +28,33 @@ public class CombinationNodePairing implements NodePairing {
                 return left.length;
         }
 
-        static final int LIMIT = 5;
-        static final List<List<int[]>> permutations = new ArrayList<>();
-
-        /**
-         * Generates and stores permutations up to a given size. If the number would be more than a limit, it provides a
-         * single permutation only.
-         *
-         * @param max The max number in the permutation
-         * @return A complete list of permutations of numbers 0...max, or a single permutation.
-         */
-        public static List<int[]> getPermutations(int max) {
-                if (max < permutations.size()) {
-                        return permutations.get(max);
-                }
-                if (max == 0) {
-                        List<int[]> result = new ArrayList<>();
-                        result.add(new int[1]);
-                        permutations.add(result);
-                        return result;
-                }
-                List<int[]> result = new ArrayList<>();
-                List<int[]> previousPermutations = getPermutations(max - 1);
-                for (var permutation : previousPermutations) {
-                        for (int pos = 0; pos <= max; pos++) {
-                                int[] newPermutation = new int[max + 1];
-                                System.arraycopy(permutation, 0, newPermutation, 0, pos);
-                                newPermutation[pos] = max;
-                                if (max - (pos + 1) >= 0)
-                                        System.arraycopy(permutation, pos + 1, newPermutation, pos + 1 + 1, max - (pos + 1));
-                                result.add(newPermutation);
-                        }
-                }
-                permutations.add(result);
-                return result;
+        private static final int LIMIT = 5;
+        // Enum-based singleton used to delay generating all permutations until they are first needed.
+        @SuppressWarnings("squid:S6548")
+        private enum PermutationsHolder {
+                INSTANCE;
+
+                final CombinationNodePairingPermutations permutations = new CombinationNodePairingPermutations(LIMIT);
         }
 
         @Override
         public List<IntIntMap> permutations() {
-                final var interval = Interval.zeroTo(this.size() - 1);
+                int limit = this.size();
+                Iterable<Integer> interval = () -> new IntervalIterator(limit);
 
                 if (isComplete()) {
-                        final List<int[]> p = getPermutations(this.size() - 1);
+                        final List<int[]> p = PermutationsHolder.INSTANCE.permutations.getPermutations(this.size() - 1);
                         return p.stream().map(x -> constructPermutationMap(interval, x)).toList();
                 } else {
                         return List.of(constructTrivialMap(interval));
                 }
         }
 
-        private IntIntMap constructTrivialMap(Interval interval) {
+        private IntIntMap constructTrivialMap(Iterable<Integer> interval) {
                 return IntIntMaps.immutable.from(interval, l -> left[l], r -> right[r]);
         }
 
-        private IntIntMap constructPermutationMap(Interval interval, int[] permutation) {
+        private IntIntMap constructPermutationMap(Iterable<Integer> interval, int[] permutation) {
                 return IntIntMaps.immutable.from(interval, l -> left[l], r -> right[permutation[r]]);
         }
 
@@ -92,4 +62,28 @@ public class CombinationNodePairing implements NodePairing {
         public boolean isComplete() {
                 return this.size() <= LIMIT;
         }
+
+        private static class IntervalIterator implements Iterator<Integer> {
+                private final int limit;
+                private int value = 0;
+
+                private IntervalIterator(int max) {
+                        this.limit = max;
+                }
+
+                @Override
+                public boolean hasNext() {
+                        return value < limit;
+                }
+
+                @Override
+                public Integer next() {
+                        if (value >= limit) {
+                                throw new NoSuchElementException("End of interval");
+                        }
+                        int next = value;
+                        value++;
+                        return next;
+                }
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/CombinationNodePairingPermutations.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/CombinationNodePairingPermutations.java
new file mode 100644
index 00000000..eacd3a2a
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/CombinationNodePairingPermutations.java
@@ -0,0 +1,57 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding.stateequivalence;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class CombinationNodePairingPermutations {
+        private final List<List<int[]>> permutations = new ArrayList<>();
+
+        public CombinationNodePairingPermutations(int max) {
+                initializePermutations(max);
+        }
+
+        public List<int[]> getPermutations(int max) {
+                if (max >= permutations.size()) {
+                        throw new IllegalArgumentException("Only permutations up to %d elements are supported".formatted(max));
+                }
+                return permutations.get(max);
+        }
+
+        /**
+         * Generates and stores permutations up to a given size. If the number would be more than a limit, it provides a
+         * single permutation only.
+         *
+         * @param max The max number in the permutation
+         * @return A complete list of permutations of numbers 0...max, or a single permutation.
+         */
+        private List<int[]> initializePermutations(int max) {
+                if (max < permutations.size()) {
+                        return permutations.get(max);
+                }
+                if (max == 0) {
+                        List<int[]> result = new ArrayList<>();
+                        result.add(new int[1]);
+                        permutations.add(result);
+                        return result;
+                }
+                List<int[]> result = new ArrayList<>();
+                List<int[]> previousPermutations = initializePermutations(max - 1);
+                for (var permutation : previousPermutations) {
+                        for (int pos = 0; pos <= max; pos++) {
+                                int[] newPermutation = new int[max + 1];
+                                System.arraycopy(permutation, 0, newPermutation, 0, pos);
+                                newPermutation[pos] = max;
+                                if (max - (pos + 1) >= 0)
+                                        System.arraycopy(permutation, pos + 1, newPermutation, pos + 1 + 1, max - (pos + 1));
+                                result.add(newPermutation);
+                        }
+                }
+                permutations.add(result);
+                return result;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/NodePairing.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/NodePairing.java
index 7e5db7a3..f45f0d2e 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/NodePairing.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/NodePairing.java
@@ -6,18 +6,18 @@
 package tools.refinery.store.statecoding.stateequivalence;
 
 import org.eclipse.collections.api.map.primitive.IntIntMap;
-import org.eclipse.collections.impl.set.mutable.primitive.IntHashSet;
+import org.eclipse.collections.api.set.primitive.IntSet;
 
 import java.util.List;
 
 public interface NodePairing {
-
         int size();
+
         List<IntIntMap> permutations();
 
         boolean isComplete();
 
-        static NodePairing constructNodePairing(IntHashSet left, IntHashSet right){
+        static NodePairing constructNodePairing(IntSet left, IntSet right){
                 if(left.size() !=  right.size()) {
                         return null;
                 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/PermutationMorphism.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/PermutationMorphism.java
index 6be0f3e7..bc4d723a 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/PermutationMorphism.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/PermutationMorphism.java
@@ -12,12 +12,12 @@ import java.util.List;
 
 public class PermutationMorphism implements Morphism {
         private final IntIntMap object2PermutationGroup;
-        private final List<List<IntIntMap>> permutationsGroups;
+        private final List<? extends List<? extends IntIntMap>> permutationsGroups;
         private final int[] selection;
         private boolean hasNext;
 
         PermutationMorphism(IntIntMap object2PermutationGroup,
-                                                List<List<IntIntMap>> permutationsGroups) {
+                                                List<? extends List<? extends IntIntMap>> permutationsGroups) {
                 this.object2PermutationGroup = object2PermutationGroup;
                 this.permutationsGroups = permutationsGroups;
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/StateEquivalenceCheckerImpl.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/StateEquivalenceCheckerImpl.java
index ef0d76a7..5a62d8a0 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/StateEquivalenceCheckerImpl.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/stateequivalence/StateEquivalenceCheckerImpl.java
@@ -6,11 +6,14 @@
 package tools.refinery.store.statecoding.stateequivalence;
 
 import org.eclipse.collections.api.factory.primitive.IntIntMaps;
+import org.eclipse.collections.api.factory.primitive.IntSets;
+import org.eclipse.collections.api.factory.primitive.LongObjectMaps;
 import org.eclipse.collections.api.map.primitive.IntIntMap;
+import org.eclipse.collections.api.map.primitive.MutableIntIntMap;
+import org.eclipse.collections.api.map.primitive.MutableLongObjectMap;
 import org.eclipse.collections.api.set.primitive.IntSet;
-import org.eclipse.collections.impl.map.mutable.primitive.IntIntHashMap;
-import org.eclipse.collections.impl.map.mutable.primitive.LongObjectHashMap;
-import org.eclipse.collections.impl.set.mutable.primitive.IntHashSet;
+import org.eclipse.collections.api.set.primitive.MutableIntSet;
+import tools.refinery.store.model.AnyInterpretation;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.statecoding.Morphism;
 import tools.refinery.store.statecoding.ObjectCode;
@@ -26,12 +29,11 @@ public class StateEquivalenceCheckerImpl implements StateEquivalenceChecker {
 
         @Override
         public EquivalenceResult constructMorphism(IntSet individuals,
-                                                                                                List<? extends Interpretation<?>> interpretations1,
-                                                                                                ObjectCode code1,
-                                                                                                List<? extends Interpretation<?>> interpretations2,
-                                                                                                ObjectCode code2)
-        {
-                IntIntHashMap object2PermutationGroup = new IntIntHashMap();
+                                                                                           List<? extends AnyInterpretation> interpretations1,
+                                                                                           ObjectCode code1,
+                                                                                           List<? extends AnyInterpretation> interpretations2,
+                                                                                           ObjectCode code2) {
+                MutableIntIntMap object2PermutationGroup = IntIntMaps.mutable.empty();
                 List<List<IntIntMap>> permutationsGroups = new ArrayList<>();
 
                 final EquivalenceResult permutations = constructPermutationNavigation(individuals,
@@ -50,7 +52,7 @@ public class StateEquivalenceCheckerImpl implements StateEquivalenceChecker {
                                 return permutations;
                         }
 
-                        if(tried >= LIMIT) {
+                        if (tried >= LIMIT) {
                                 return EquivalenceResult.UNKNOWN;
                         }
 
@@ -58,22 +60,22 @@ public class StateEquivalenceCheckerImpl implements StateEquivalenceChecker {
                         tried++;
                 } while (hasNext);
 
-                if(permutations == EquivalenceResult.UNKNOWN) {
+                if (permutations == EquivalenceResult.UNKNOWN) {
                         return EquivalenceResult.UNKNOWN;
                 } else {
                         return EquivalenceResult.DIFFERENT;
                 }
         }
 
-        private LongObjectHashMap<IntHashSet> indexByHash(ObjectCode code, IntSet individuals) {
-                LongObjectHashMap<IntHashSet> result = new LongObjectHashMap<>();
+        private MutableLongObjectMap<MutableIntSet> indexByHash(ObjectCode code, IntSet individuals) {
+                MutableLongObjectMap<MutableIntSet> result = LongObjectMaps.mutable.empty();
                 for (int o = 0; o < code.getSize(); o++) {
-                        if(! individuals.contains(o)){
+                        if (!individuals.contains(o)) {
                                 long hash = code.get(o);
-                                if(hash != 0) {
+                                if (hash != 0) {
                                         var equivalenceClass = result.get(hash);
                                         if (equivalenceClass == null) {
-                                                equivalenceClass = new IntHashSet();
+                                                equivalenceClass = IntSets.mutable.empty();
                                                 result.put(hash, equivalenceClass);
                                         }
                                         equivalenceClass.add(o);
@@ -83,11 +85,9 @@ public class StateEquivalenceCheckerImpl implements StateEquivalenceChecker {
                 return result;
         }
 
-        private EquivalenceResult constructPermutationNavigation(IntSet individuals,
-                                                                                                                         LongObjectHashMap<IntHashSet> map1,
-                                                                                                                         LongObjectHashMap<IntHashSet> map2,
-                                                                                                                         IntIntHashMap object2OptionIndex,
-                                                                                                                         List<List<IntIntMap>> listOfOptions) {
+        private EquivalenceResult constructPermutationNavigation(
+                        IntSet individuals, MutableLongObjectMap<MutableIntSet> map1, MutableLongObjectMap<MutableIntSet> map2,
+                        MutableIntIntMap object2OptionIndex, List<List<IntIntMap>> listOfOptions) {
                 if (map1.size() != map2.size()) {
                         return EquivalenceResult.DIFFERENT;
                 }
@@ -116,27 +116,28 @@ public class StateEquivalenceCheckerImpl implements StateEquivalenceChecker {
                         listOfOptions.add(pairing.permutations());
                 }
 
-                individuals.forEach(o -> listOfOptions.add(o,List.of(IntIntMaps.immutable.of(o,o))));
+                individuals.forEach(o -> listOfOptions.add(o, List.of(IntIntMaps.immutable.of(o, o))));
 
-                if(allComplete) {
+                if (allComplete) {
                         return EquivalenceResult.ISOMORPHIC;
                 } else {
                         return EquivalenceResult.UNKNOWN;
                 }
         }
 
-        private boolean testMorphism(List<? extends Interpretation<?>> s, List<? extends Interpretation<?>> t, Morphism m) {
+        private boolean testMorphism(List<? extends AnyInterpretation> s, List<? extends AnyInterpretation> t,
+                                                                 Morphism m) {
                 for (int interpretationIndex = 0; interpretationIndex < s.size(); interpretationIndex++) {
                         var sI = s.get(interpretationIndex);
                         var tI = t.get(interpretationIndex);
 
-                        var cursor = sI.getAll();
+                        var cursor = ((Interpretation<?>) sI).getAll();
                         while (cursor.move()) {
                                 final Tuple sTuple = cursor.getKey();
                                 final Object sValue = cursor.getValue();
 
                                 final Tuple tTuple = apply(sTuple, m);
-                                final Object tValue = tI.get(tTuple);
+                                final Object tValue = ((Interpretation<?>) tI).get(tTuple);
 
                                 if (!Objects.equals(sValue, tValue)) {
                                         return false;
diff --git a/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple.java b/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple.java
index aae7b344..e9761763 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple.java
@@ -12,6 +12,8 @@ public sealed interface Tuple extends Comparable<Tuple> permits Tuple0, Tuple1,
 
         int get(int element);
 
+        Tuple set(int element, int value);
+
         @Override
         default int compareTo(@NotNull Tuple other) {
                 int size = getSize();
diff --git a/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple0.java b/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple0.java
index a9aa9bf2..5f525798 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple0.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple0.java
@@ -29,6 +29,11 @@ public final class Tuple0 implements Tuple {
         }
 
         @Override
+        public Tuple set(int element, int value) {
+                throw new IndexOutOfBoundsException(element);
+        }
+
+        @Override
         public String toString() {
                 return TUPLE_BEGIN + TUPLE_END;
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple1.java b/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple1.java
index 388ee3a9..fb9497d2 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple1.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple1.java
@@ -38,6 +38,14 @@ public final class Tuple1 implements Tuple {
         }
 
         @Override
+        public Tuple set(int element, int value) {
+                if (element == 0) {
+                        return Tuple.of(value);
+                }
+                throw new IndexOutOfBoundsException(element);
+        }
+
+        @Override
         public String toString() {
                 return TUPLE_BEGIN + value0 + TUPLE_END;
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple2.java b/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple2.java
index 6d886fd3..2213df97 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple2.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple2.java
@@ -25,6 +25,15 @@ public record Tuple2(int value0, int value1) implements Tuple {
         }
 
         @Override
+        public Tuple set(int element, int value) {
+                return switch (element) {
+                        case 0 -> Tuple.of(value, value1);
+                        case 1 -> Tuple.of(value0, value);
+                        default -> throw new ArrayIndexOutOfBoundsException(element);
+                };
+        }
+
+        @Override
         public String toString() {
                 return TUPLE_BEGIN + value0 + TUPLE_SEPARATOR + value1 + TUPLE_END;
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple3.java b/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple3.java
index 734e45c2..417770e8 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple3.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple3.java
@@ -26,6 +26,16 @@ public record Tuple3(int value0, int value1, int value2) implements Tuple {
         }
 
         @Override
+        public Tuple set(int element, int value) {
+                return switch (element) {
+                        case 0 -> Tuple.of(value, value1, value2);
+                        case 1 -> Tuple.of(value0, value, value2);
+                        case 2 -> Tuple.of(value0, value1, value);
+                        default -> throw new ArrayIndexOutOfBoundsException(element);
+                };
+        }
+
+        @Override
         public String toString() {
                 return TUPLE_BEGIN + value0 + TUPLE_SEPARATOR + value1 + TUPLE_SEPARATOR + value2 + TUPLE_END;
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple4.java b/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple4.java
index e1b93e7b..c4915198 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple4.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/tuple/Tuple4.java
@@ -27,6 +27,17 @@ public record Tuple4(int value0, int value1, int value2, int value3) implements
         }
 
         @Override
+        public Tuple set(int element, int value) {
+                return switch (element) {
+                        case 0 -> Tuple.of(value, value1, value2, value3);
+                        case 1 -> Tuple.of(value0, value, value2, value3);
+                        case 2 -> Tuple.of(value0, value1, value, value3);
+                        case 3 -> Tuple.of(value0, value1, value2, value);
+                        default -> throw new ArrayIndexOutOfBoundsException(element);
+                };
+        }
+
+        @Override
         public String toString() {
                 return TUPLE_BEGIN + value0 + TUPLE_SEPARATOR + value1 + TUPLE_SEPARATOR + value2 + TUPLE_SEPARATOR + value3 +
                                 TUPLE_END;
diff --git a/subprojects/store/src/main/java/tools/refinery/store/tuple/TupleN.java b/subprojects/store/src/main/java/tools/refinery/store/tuple/TupleN.java
index b66af491..b42b4b6a 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/tuple/TupleN.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/tuple/TupleN.java
@@ -32,6 +32,16 @@ public final class TupleN implements Tuple {
         }
 
         @Override
+        public Tuple set(int element, int value) {
+                int size = getSize();
+                var newValues = new int[size];
+                for (int i = 0; i < size; i++) {
+                        newValues[i] = element == i ? value : values[i];
+                }
+                return Tuple.of(newValues);
+        }
+
+        @Override
         public String toString() {
                 var valuesString = Arrays.stream(values)
                                 .mapToObj(Integer::toString)
diff --git a/subprojects/store/src/main/java/tools/refinery/store/util/CancellationToken.java b/subprojects/store/src/main/java/tools/refinery/store/util/CancellationToken.java
new file mode 100644
index 00000000..be294013
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/util/CancellationToken.java
@@ -0,0 +1,13 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.util;
+
+@FunctionalInterface
+public interface CancellationToken {
+        CancellationToken NONE = () -> {};
+
+        void checkCancelled();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/util/CycleDetectingMapper.java b/subprojects/store/src/main/java/tools/refinery/store/util/CycleDetectingMapper.java
index 78ad2ad7..2e302663 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/util/CycleDetectingMapper.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/util/CycleDetectingMapper.java
@@ -20,6 +20,10 @@ public class CycleDetectingMapper<T, R> {
 
         private final Map<T, R> results = new HashMap<>();
 
+        public CycleDetectingMapper(Function<T, R> doMap) {
+                this(Objects::toString, doMap);
+        }
+
         public CycleDetectingMapper(Function<T, String> getName, Function<T, R> doMap) {
                 this.getName = getName;
                 this.doMap = doMap;