feat: generate multiple solutions

Switch to partial interpretation based neighborhood calculation when multiple
models are request to avoid returning isomorphic models.

8 files changed, 327 insertions, 336 deletions

diff --git a/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java b/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java
index b1c28df0..0fb97316 100644
--- a/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java
+++ b/subprojects/generator-cli/src/main/java/tools/refinery/generator/cli/commands/GenerateCommand.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -17,9 +17,12 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.regex.Pattern;
 
 @Parameters(commandDescription = "Generate a model from a partial model")
 public class GenerateCommand {
+        private static final Pattern EXTENSION_REGEX = Pattern.compile("(.+)\\.([^./\\\\]+)");
+
         @Inject
         private ProblemLoader loader;
 
@@ -31,6 +34,7 @@ public class GenerateCommand {
         private List<String> scopes = new ArrayList<>();
         private List<String> overrideScopes = new ArrayList<>();
         private long randomSeed = 1;
+        private int count = 1;
 
         @Parameter(description = "input path", required = true)
         public void setInputPath(String inputPath) {
@@ -57,21 +61,47 @@ public class GenerateCommand {
                 this.randomSeed = randomSeed;
         }
 
+        @Parameter(names = {"-solution-number", "-n"}, description = "Maximum number of solutions")
+        public void setCount(int count) {
+                if (count <= 0) {
+                        throw new IllegalArgumentException("Count must be positive");
+                }
+                this.count = count;
+        }
+
         public void run() throws IOException {
+                if (count > 1 && isStandardStream(outputPath)) {
+                        throw new IllegalArgumentException("Must provide output path if count is larger than 1");
+                }
                 loader.extraPath(System.getProperty("user.dir"));
                 var problem = isStandardStream(inputPath) ? loader.loadStream(System.in) : loader.loadFile(inputPath);
                 problem = loader.loadScopeConstraints(problem, scopes, overrideScopes);
+                generatorFactory.partialInterpretationBasedNeighbourhoods(count >= 2);
                 var generator = generatorFactory.createGenerator(problem);
                 generator.setRandomSeed(randomSeed);
+                generator.setMaxNumberOfSolutions(count);
                 generator.generate();
-                var solution = generator.serializeSolution();
-                var solutionResource = solution.eResource();
                 var saveOptions = Map.of();
-                if (isStandardStream(outputPath)) {
-                        printSolution(solutionResource, saveOptions);
+                if (count == 1) {
+                        var solution = generator.serializeSolution();
+                        var solutionResource = solution.eResource();
+                        if (isStandardStream(outputPath)) {
+                                printSolution(solutionResource, saveOptions);
+                        } else {
+                                try (var outputStream = new FileOutputStream(outputPath)) {
+                                        solutionResource.save(outputStream, saveOptions);
+                                }
+                        }
                 } else {
-                        try (var outputStream = new FileOutputStream(outputPath)) {
-                                solutionResource.save(outputStream, saveOptions);
+                        int solutionCount = generator.getSolutionCount();
+                        for (int i = 0; i < solutionCount; i++) {
+                                generator.loadSolution(i);
+                                var solution = generator.serializeSolution();
+                                var solutionResource = solution.eResource();
+                                var pathWithIndex = getFileNameWithIndex(outputPath, i + 1);
+                                try (var outputStream = new FileOutputStream(pathWithIndex)) {
+                                        solutionResource.save(outputStream, saveOptions);
+                                }
                         }
                 }
         }
@@ -85,4 +115,12 @@ public class GenerateCommand {
         private void printSolution(Resource solutionResource, Map<?, ?> saveOptions) throws IOException {
                 solutionResource.save(System.out, saveOptions);
         }
+
+        private String getFileNameWithIndex(String simpleName, int index) {
+                var match = EXTENSION_REGEX.matcher(simpleName);
+                if (match.matches()) {
+                        return "%s_%03d.%s".formatted(match.group(1), index, match.group(2));
+                }
+                return "%s_%03d".formatted(simpleName, index);
+        }
 }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
index 36190b76..8dff5622 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGenerator.java
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -11,6 +11,7 @@ import tools.refinery.language.semantics.ProblemTrace;
 import tools.refinery.language.semantics.SolutionSerializer;
 import tools.refinery.logic.AbstractValue;
 import tools.refinery.store.dse.strategy.BestFirstStoreManager;
+import tools.refinery.store.dse.transition.statespace.SolutionStore;
 import tools.refinery.store.map.Version;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
@@ -22,7 +23,8 @@ public class ModelGenerator extends ModelFacade {
         private final Version initialVersion;
         private final Provider<SolutionSerializer> solutionSerializerProvider;
         private long randomSeed = 1;
-        private boolean lastGenerationSuccessful;
+        private int maxNumberOfSolutions = 1;
+        private SolutionStore solutionStore;
 
         ModelGenerator(ProblemTrace problemTrace, ModelStore store, ModelSeed modelSeed,
                                    Provider<SolutionSerializer> solutionSerializerProvider) {
@@ -37,26 +39,51 @@ public class ModelGenerator extends ModelFacade {
 
         public void setRandomSeed(long randomSeed) {
                 this.randomSeed = randomSeed;
-                this.lastGenerationSuccessful = false;
+                this.solutionStore = null;
         }
 
+        public int getMaxNumberOfSolutions() {
+                return maxNumberOfSolutions;
+        }
+
+        public void setMaxNumberOfSolutions(int maxNumberOfSolutions) {
+                this.maxNumberOfSolutions = maxNumberOfSolutions;
+                this.solutionStore = null;
+        }
+
+        public int getSolutionCount() {
+                if (!isLastGenerationSuccessful()) {
+                        return 0;
+                }
+                return this.solutionStore.getSolutions().size();
+        }
+
+        public void loadSolution(int index) {
+                if (index >= getSolutionCount()) {
+                        throw new IndexOutOfBoundsException("No such solution");
+                }
+                getModel().restore(solutionStore.getSolutions().get(index).version());
+        }
+
+        // It makes more sense to check for success than for failure.
+        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
         public boolean isLastGenerationSuccessful() {
-                return lastGenerationSuccessful;
+                return solutionStore != null;
         }
 
         // This method only makes sense if it returns {@code true} on success.
         @SuppressWarnings("BooleanMethodIsAlwaysInverted")
         public boolean tryGenerate() {
-                lastGenerationSuccessful = false;
+                solutionStore = null;
                 randomSeed++;
-                var bestFirst = new BestFirstStoreManager(getModelStore(), 1);
+                var bestFirst = new BestFirstStoreManager(getModelStore(), maxNumberOfSolutions);
                 bestFirst.startExploration(initialVersion, randomSeed);
                 var solutions = bestFirst.getSolutionStore().getSolutions();
                 if (solutions.isEmpty()) {
                         return false;
                 }
                 getModel().restore(solutions.getFirst().version());
-                lastGenerationSuccessful = true;
+                solutionStore = bestFirst.getSolutionStore();
                 return true;
         }
 
@@ -80,7 +107,7 @@ public class ModelGenerator extends ModelFacade {
         }
 
         private void checkSuccessfulGeneration() {
-                if (!lastGenerationSuccessful) {
+                if (!isLastGenerationSuccessful()) {
                         throw new IllegalStateException("No generated model is available");
                 }
         }
diff --git a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java
index 587601f2..ec273cf4 100644
--- a/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java
+++ b/subprojects/generator/src/main/java/tools/refinery/generator/ModelGeneratorFactory.java
@@ -15,8 +15,11 @@ import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.interpreter.QueryInterpreterAdapter;
 import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.interpretation.PartialNeighbourhoodCalculator;
 import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.statecoding.StateCodeCalculatorFactory;
 import tools.refinery.store.statecoding.StateCoderAdapter;
+import tools.refinery.store.statecoding.neighbourhood.NeighbourhoodCalculator;
 import tools.refinery.store.util.CancellationToken;
 
 import java.util.Collection;
@@ -33,6 +36,8 @@ public final class ModelGeneratorFactory {
 
         private boolean debugPartialInterpretations;
 
+        private boolean partialInterpretationBasedNeighbourhoods;
+
         public ModelGeneratorFactory cancellationToken(CancellationToken cancellationToken) {
                 this.cancellationToken = cancellationToken;
                 return this;
@@ -43,6 +48,10 @@ public final class ModelGeneratorFactory {
                 return this;
         }
 
+        public void partialInterpretationBasedNeighbourhoods(boolean partialInterpretationBasedNeighbourhoods) {
+                this.partialInterpretationBasedNeighbourhoods = partialInterpretationBasedNeighbourhoods;
+        }
+
         public ModelGenerator createGenerator(Problem problem) {
                 var initializer = initializerProvider.get();
                 initializer.readProblem(problem);
@@ -51,7 +60,8 @@ public final class ModelGeneratorFactory {
                                 .cancellationToken(cancellationToken)
                                 .with(QueryInterpreterAdapter.builder())
                                 .with(PropagationAdapter.builder())
-                                .with(StateCoderAdapter.builder())
+                                .with(StateCoderAdapter.builder()
+                                                .stateCodeCalculatorFactory(getStateCoderCalculatorFactory()))
                                 .with(DesignSpaceExplorationAdapter.builder())
                                 .with(ReasoningAdapter.builder()
                                                 .requiredInterpretations(getRequiredInterpretations()));
@@ -62,7 +72,13 @@ public final class ModelGeneratorFactory {
         }
 
         private Collection<Concreteness> getRequiredInterpretations() {
-                return debugPartialInterpretations ? Set.of(Concreteness.PARTIAL, Concreteness.CANDIDATE) :
+                return debugPartialInterpretations || partialInterpretationBasedNeighbourhoods ?
+                                Set.of(Concreteness.PARTIAL, Concreteness.CANDIDATE) :
                                 Set.of(Concreteness.CANDIDATE);
         }
+
+        private StateCodeCalculatorFactory getStateCoderCalculatorFactory() {
+                return partialInterpretationBasedNeighbourhoods ? PartialNeighbourhoodCalculator.FACTORY :
+                                NeighbourhoodCalculator::new;
+        }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/PartialNeighbourhoodCalculator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/PartialNeighbourhoodCalculator.java
new file mode 100644
index 00000000..859cf7c1
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/PartialNeighbourhoodCalculator.java
@@ -0,0 +1,63 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.interpretation;
+
+import org.eclipse.collections.api.set.primitive.IntSet;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.statecoding.StateCodeCalculatorFactory;
+import tools.refinery.store.statecoding.StateCoderResult;
+import tools.refinery.store.statecoding.neighbourhood.AbstractNeighbourhoodCalculator;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.List;
+
+public class PartialNeighbourhoodCalculator extends AbstractNeighbourhoodCalculator<PartialInterpretation<?, ?>> {
+        private final ModelQueryAdapter queryAdapter;
+
+        public static final StateCodeCalculatorFactory FACTORY =
+                        (model, ignoredInterpretations, individuals) -> new PartialNeighbourhoodCalculator(model, individuals);
+
+        protected PartialNeighbourhoodCalculator(Model model, IntSet individuals) {
+                super(model, individuals);
+                queryAdapter = model.getAdapter(ModelQueryAdapter.class);
+        }
+
+        @Override
+        public StateCoderResult calculateCodes() {
+                queryAdapter.flushChanges();
+                return super.calculateCodes();
+        }
+
+        @Override
+        protected List<PartialInterpretation<?, ?>> getInterpretations() {
+                var adapter = getModel().getAdapter(ReasoningAdapter.class);
+                var partialSymbols = adapter.getStoreAdapter().getPartialSymbols();
+                return partialSymbols.stream()
+                                .<PartialInterpretation<?, ?>>map(partialSymbol ->
+                                                adapter.getPartialInterpretation(Concreteness.PARTIAL, (PartialSymbol<?, ?>) partialSymbol))
+                                .toList();
+        }
+
+        @Override
+        protected int getArity(PartialInterpretation<?, ?> interpretation) {
+                return interpretation.getPartialSymbol().arity();
+        }
+
+        @Override
+        protected Object getNullValue(PartialInterpretation<?, ?> interpretation) {
+                return interpretation.get(Tuple.of());
+        }
+
+        @Override
+        protected Cursor<Tuple, ?> getCursor(PartialInterpretation<?, ?> interpretation) {
+                return interpretation.getAll();
+        }
+}
diff --git a/subprojects/store/build.gradle.kts b/subprojects/store/build.gradle.kts
index f96922a9..e48c0088 100644
--- a/subprojects/store/build.gradle.kts
+++ b/subprojects/store/build.gradle.kts
@@ -10,6 +10,6 @@ plugins {
 }
 
 dependencies {
-        implementation(libs.eclipseCollections.api)
+        api(libs.eclipseCollections.api)
         runtimeOnly(libs.eclipseCollections)
 }
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 4cef6786..5bfc4725 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
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -8,39 +8,87 @@ 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 tools.refinery.store.model.AnyInterpretation;
-import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.map.Cursor;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.statecoding.ObjectCode;
+import tools.refinery.store.statecoding.StateCodeCalculator;
+import tools.refinery.store.statecoding.StateCoderResult;
 import tools.refinery.store.tuple.Tuple;
-import tools.refinery.store.tuple.Tuple0;
 
 import java.util.*;
 
-public abstract class AbstractNeighbourhoodCalculator {
-        protected final Model model;
-        protected final List<AnyInterpretation> nullImpactValues;
-        protected final LinkedHashMap<AnyInterpretation, long[]> impactValues;
-        protected final MutableIntLongMap individualHashValues = IntLongMaps.mutable.empty();
+public abstract class AbstractNeighbourhoodCalculator<T> implements StateCodeCalculator {
+        private final Model model;
+        private final IntSet individuals;
+        private List<T> nullImpactValues;
+        private LinkedHashMap<T, long[]> impactValues;
+        private MutableIntLongMap individualHashValues;
+        private ObjectCodeImpl previousObjectCode = new ObjectCodeImpl();
+        private ObjectCodeImpl nextObjectCode = new ObjectCodeImpl();
 
         protected static final long PRIME = 31;
 
-        protected AbstractNeighbourhoodCalculator(Model model, List<? extends AnyInterpretation> interpretations,
-                                                                                          IntSet individuals) {
+        protected AbstractNeighbourhoodCalculator(Model model, IntSet individuals) {
                 this.model = model;
-                this.nullImpactValues = new ArrayList<>();
-                this.impactValues = new LinkedHashMap<>();
+                this.individuals = individuals;
+        }
+
+        protected Model getModel() {
+                return model;
+        }
+
+        protected abstract List<T> getInterpretations();
+
+        protected abstract int getArity(T interpretation);
+
+        protected abstract Object getNullValue(T interpretation);
+
+        // We need the wildcard here, because we don't know the value type.
+        @SuppressWarnings("squid:S1452")
+        protected abstract Cursor<Tuple, ?> getCursor(T interpretation);
+
+        @Override
+        public StateCoderResult calculateCodes() {
+                model.checkCancelled();
+                ensureInitialized();
+                previousObjectCode.clear();
+                nextObjectCode.clear();
+                initializeWithIndividuals(previousObjectCode);
+
+                int rounds = 0;
+                do {
+                        model.checkCancelled();
+                        constructNextObjectCodes(previousObjectCode, nextObjectCode);
+                        var tempObjectCode = previousObjectCode;
+                        previousObjectCode = nextObjectCode;
+                        nextObjectCode = tempObjectCode;
+                        nextObjectCode.clear();
+                        rounds++;
+                } while (rounds <= 7 && rounds <= previousObjectCode.getEffectiveSize());
+
+                long result = calculateLastSum(previousObjectCode);
+                return new StateCoderResult((int) result, previousObjectCode);
+        }
+
+        private void ensureInitialized() {
+                if (impactValues != null) {
+                        return;
+                }
+
+                nullImpactValues = new ArrayList<>();
+                impactValues = new LinkedHashMap<>();
+                individualHashValues = IntLongMaps.mutable.empty();
                 // Random isn't used for cryptographical purposes but just to assign distinguishable identifiers to symbols.
                 @SuppressWarnings("squid:S2245")
                 Random random = new Random(1);
 
                 var individualsInOrder = individuals.toSortedList(Integer::compare);
-                for(int i = 0; i<individualsInOrder.size(); i++) {
+                for (int i = 0; i < individualsInOrder.size(); i++) {
                         individualHashValues.put(individualsInOrder.get(i), random.nextLong());
                 }
 
-                for (AnyInterpretation interpretation : interpretations) {
-                        int arity = interpretation.getSymbol().arity();
+                for (var interpretation : getInterpretations()) {
+                        int arity = getArity(interpretation);
                         if (arity == 0) {
                                 nullImpactValues.add(interpretation);
                         } else {
@@ -50,6 +98,88 @@ public abstract class AbstractNeighbourhoodCalculator {
                                 }
                                 impactValues.put(interpretation, impact);
                         }
+
+                }
+        }
+
+        private long calculateLastSum(ObjectCode codes) {
+                long result = 0;
+                for (var nullImpactValue : nullImpactValues) {
+                        result = result * PRIME + Objects.hashCode(getNullValue(nullImpactValue));
+                }
+
+                for (int i = 0; i < codes.getSize(); i++) {
+                        final long hash = codes.get(i);
+                        result += hash*PRIME;
+                }
+
+                return result;
+        }
+
+        private void constructNextObjectCodes(ObjectCodeImpl previous, ObjectCodeImpl next) {
+                for (var impactValueEntry : this.impactValues.entrySet()) {
+                        model.checkCancelled();
+                        var interpretation = impactValueEntry.getKey();
+                        var cursor = getCursor(interpretation);
+                        int arity = getArity(interpretation);
+                        long[] impactValue = impactValueEntry.getValue();
+                        impactCalculation(previous, next, impactValue, cursor, arity);
+                }
+        }
+
+        protected void impactCalculation(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValue,
+                                                                         Cursor<Tuple, ?> cursor, int arity) {
+                switch (arity) {
+                case 1 -> {
+                        while (cursor.move()) {
+                                impactCalculation1(previous, next, impactValue, cursor);
+                        }
+                }
+                case 2 -> {
+                        while (cursor.move()) {
+                                impactCalculation2(previous, next, impactValue, cursor);
+                        }
+                }
+                default -> {
+                        while (cursor.move()) {
+                                impactCalculationN(previous, next, impactValue, cursor);
+                        }
+                }
+                }
+        }
+
+        private void impactCalculation1(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues,
+                                                                        Cursor<Tuple, ?> cursor) {
+
+                Tuple tuple = cursor.getKey();
+                int o = tuple.get(0);
+                Object value = cursor.getValue();
+                long tupleHash = getTupleHash1(tuple, value, previous);
+                addHash(next, o, impactValues[0], tupleHash);
+        }
+
+        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);
+
+                Object value = cursor.getValue();
+                long tupleHash = getTupleHash2(tuple, value, previous);
+
+                addHash(next, o1, impactValues[0], tupleHash);
+                addHash(next, o2, impactValues[1], tupleHash);
+        }
+
+        private void impactCalculationN(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues,
+                                                                        Cursor<Tuple, ?> cursor) {
+                final Tuple tuple = cursor.getKey();
+
+                Object value = cursor.getValue();
+                long tupleHash = getTupleHashN(tuple, value, previous);
+
+                for (int i = 0; i < tuple.getSize(); i++) {
+                        addHash(next, tuple.get(i), impactValues[i], tupleHash);
                 }
         }
 
@@ -88,13 +218,4 @@ public abstract class AbstractNeighbourhoodCalculator {
                 long x = tupleHash * impact;
                 objectCodeImpl.set(o, objectCodeImpl.get(o) + x);
         }
-
-        protected long calculateModelCode(long lastSum) {
-                long result = 0;
-                for (var nullImpactValue : nullImpactValues) {
-                        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
deleted file mode 100644
index 04335141..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/neighbourhood/LazyNeighbourhoodCalculator.java
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-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 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;
-
-import java.util.List;
-
-public class LazyNeighbourhoodCalculator extends AbstractNeighbourhoodCalculator implements StateCodeCalculator {
-        public LazyNeighbourhoodCalculator(Model model, List<? extends AnyInterpretation> interpretations,
-                                                                           IntSet individuals) {
-                super(model, interpretations, individuals);
-        }
-
-        public StateCoderResult calculateCodes() {
-                ObjectCodeImpl previousObjectCode = new ObjectCodeImpl();
-                MutableLongIntMap prevHash2Amount = LongIntMaps.mutable.empty();
-
-                long lastSum;
-                // All hash code is 0, except to the individuals.
-                int lastSize = 1;
-                boolean first = true;
-
-                boolean grows;
-                int rounds = 0;
-                do {
-                        final ObjectCodeImpl nextObjectCode;
-                        if (first) {
-                                nextObjectCode = new ObjectCodeImpl();
-                                initializeWithIndividuals(nextObjectCode);
-                        } else {
-                                nextObjectCode = new ObjectCodeImpl(previousObjectCode);
-                        }
-                        constructNextObjectCodes(previousObjectCode, nextObjectCode, prevHash2Amount);
-
-                        MutableLongIntMap nextHash2Amount = LongIntMaps.mutable.empty();
-                        lastSum = calculateLastSum(previousObjectCode, nextObjectCode, prevHash2Amount, nextHash2Amount);
-
-                        int nextSize = nextHash2Amount.size();
-                        grows = nextSize > lastSize;
-                        lastSize = nextSize;
-                        first = false;
-
-                        previousObjectCode = nextObjectCode;
-                        prevHash2Amount = nextHash2Amount;
-                } while (grows && rounds++ < 4/*&& lastSize < previousObjectCode.getSize()*/);
-
-                long result = calculateModelCode(lastSum);
-
-                return new StateCoderResult((int) result, previousObjectCode);
-        }
-
-        private long calculateLastSum(ObjectCodeImpl previous, ObjectCodeImpl next, LongIntMap hash2Amount,
-                                                                  MutableLongIntMap nextHash2Amount) {
-                long lastSum = 0;
-                for (int i = 0; i < next.getSize(); i++) {
-                        final long hash;
-                        if (isUnique(hash2Amount, previous, i)) {
-                                hash = previous.get(i);
-                                next.set(i, hash);
-                        } else {
-                                hash = next.get(i);
-                        }
-
-                        final int amount = nextHash2Amount.get(hash);
-                        nextHash2Amount.put(hash, amount + 1);
-
-                        final long shifted1 = hash >>> 8;
-                        final long shifted2 = hash << 8;
-                        final long shifted3 = hash >> 2;
-                        lastSum += shifted1 * shifted3 + shifted2;
-                }
-                return lastSum;
-        }
-
-        private void constructNextObjectCodes(ObjectCodeImpl previous, ObjectCodeImpl next, LongIntMap hash2Amount) {
-                for (var impactValueEntry : this.impactValues.entrySet()) {
-                        Interpretation<?> interpretation = (Interpretation<?>) impactValueEntry.getKey();
-                        var cursor = interpretation.getAll();
-                        int arity = interpretation.getSymbol().arity();
-                        long[] impactValue = impactValueEntry.getValue();
-
-                        if (arity == 1) {
-                                while (cursor.move()) {
-                                        lazyImpactCalculation1(hash2Amount, previous, next, impactValue, cursor);
-                                }
-                        } else if (arity == 2) {
-                                while (cursor.move()) {
-                                        lazyImpactCalculation2(hash2Amount, previous, next, impactValue, cursor);
-                                }
-                        } else {
-                                while (cursor.move()) {
-                                        lazyImpactCalculationN(hash2Amount, previous, next, impactValue, cursor);
-                                }
-                        }
-                }
-        }
-
-        private boolean isUnique(LongIntMap hash2Amount, ObjectCodeImpl objectCodeImpl, int object) {
-                final long hash = objectCodeImpl.get(object);
-                if (hash == 0) {
-                        return false;
-                }
-                final int amount = hash2Amount.get(hash);
-                return amount == 1;
-        }
-
-        private void lazyImpactCalculation1(LongIntMap hash2Amount, ObjectCodeImpl previous, ObjectCodeImpl next,
-                                                                                long[] impactValues, Cursor<Tuple, ?> cursor) {
-
-                Tuple tuple = cursor.getKey();
-                int o = tuple.get(0);
-
-                if (isUnique(hash2Amount, previous, o)) {
-                        next.ensureSize(o);
-                } else {
-                        Object value = cursor.getValue();
-                        long tupleHash = getTupleHash1(tuple, value, previous);
-
-                        addHash(next, o, impactValues[0], tupleHash);
-                }
-        }
-
-        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);
-
-                final boolean u1 = isUnique(hash2Amount, previous, o1);
-                final boolean u2 = isUnique(hash2Amount, previous, o2);
-
-                if (u1 && u2) {
-                        next.ensureSize(o1);
-                        next.ensureSize(o2);
-                } else {
-                        Object value = cursor.getValue();
-                        long tupleHash = getTupleHash2(tuple, value, previous);
-
-                        if (!u1) {
-                                addHash(next, o1, impactValues[0], tupleHash);
-                                next.ensureSize(o2);
-                        }
-                        if (!u2) {
-                                next.ensureSize(o1);
-                                addHash(next, o2, impactValues[1], tupleHash);
-                        }
-                }
-        }
-
-        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()];
-                boolean allUnique = true;
-                for (int i = 0; i < tuple.getSize(); i++) {
-                        final boolean isUnique = isUnique(hash2Amount, previous, tuple.get(i));
-                        uniques[i] = isUnique;
-                        allUnique &= isUnique;
-                }
-
-                if (allUnique) {
-                        for (int i = 0; i < tuple.getSize(); i++) {
-                                next.ensureSize(tuple.get(i));
-                        }
-                } else {
-                        Object value = cursor.getValue();
-                        long tupleHash = getTupleHashN(tuple, value, previous);
-
-                        for (int i = 0; i < tuple.getSize(); i++) {
-                                int o = tuple.get(i);
-                                if (!uniques[i]) {
-                                        addHash(next, o, impactValues[i], tupleHash);
-                                } else {
-                                        next.ensureSize(o);
-                                }
-                        }
-                }
-        }
-
-}
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 5e6de53b..f6071c5b 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
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2023-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
@@ -9,115 +9,36 @@ 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;
 import tools.refinery.store.tuple.Tuple;
-import tools.refinery.store.tuple.Tuple0;
 
 import java.util.List;
-import java.util.Objects;
 
-public class NeighbourhoodCalculator extends AbstractNeighbourhoodCalculator implements StateCodeCalculator {
-        private ObjectCodeImpl previousObjectCode = new ObjectCodeImpl();
-        private ObjectCodeImpl nextObjectCode = new ObjectCodeImpl();
+public class NeighbourhoodCalculator extends AbstractNeighbourhoodCalculator<Interpretation<?>> {
+        private final List<Interpretation<?>> interpretations;
 
-        public NeighbourhoodCalculator(Model model, List<? extends Interpretation<?>> interpretations, IntSet individuals) {
-                super(model, interpretations, individuals);
+        public NeighbourhoodCalculator(Model model, List<? extends Interpretation<?>> interpretations,
+                                                                   IntSet individuals) {
+                super(model, individuals);
+                this.interpretations = List.copyOf(interpretations);
         }
 
-        public StateCoderResult calculateCodes() {
-                model.checkCancelled();
-                previousObjectCode.clear();
-                nextObjectCode.clear();
-                initializeWithIndividuals(previousObjectCode);
-
-                int rounds = 0;
-                do {
-                        model.checkCancelled();
-                        constructNextObjectCodes(previousObjectCode, nextObjectCode);
-                        var tempObjectCode = previousObjectCode;
-                        previousObjectCode = nextObjectCode;
-                        nextObjectCode = tempObjectCode;
-                        nextObjectCode.clear();
-                        rounds++;
-                } while (rounds <= 7 && rounds <= previousObjectCode.getEffectiveSize());
-
-                long result = calculateLastSum(previousObjectCode);
-                return new StateCoderResult((int) result, previousObjectCode);
+        @Override
+        public List<Interpretation<?>> getInterpretations() {
+                return interpretations;
         }
 
-        private long calculateLastSum(ObjectCode codes) {
-                long result = 0;
-                for (var nullImpactValue : nullImpactValues) {
-                        result = result * PRIME + Objects.hashCode(((Interpretation<?>) nullImpactValue).get(Tuple0.INSTANCE));
-                }
-
-                for (int i = 0; i < codes.getSize(); i++) {
-                        final long hash = codes.get(i);
-                        result += hash*PRIME;
-                }
-
-                return result;
+        @Override
+        protected int getArity(Interpretation<?> interpretation) {
+                return interpretation.getSymbol().arity();
         }
 
-        private void constructNextObjectCodes(ObjectCodeImpl previous, ObjectCodeImpl next) {
-                for (var impactValueEntry : this.impactValues.entrySet()) {
-                        model.checkCancelled();
-                        Interpretation<?> interpretation = (Interpretation<?>) impactValueEntry.getKey();
-                        var cursor = interpretation.getAll();
-                        int arity = interpretation.getSymbol().arity();
-                        long[] impactValue = impactValueEntry.getValue();
-
-                        if (arity == 1) {
-                                while (cursor.move()) {
-                                        impactCalculation1(previous, next, impactValue, cursor);
-                                }
-                        } else if (arity == 2) {
-                                while (cursor.move()) {
-                                        impactCalculation2(previous, next, impactValue, cursor);
-                                }
-                        } else {
-                                while (cursor.move()) {
-                                        impactCalculationN(previous, next, impactValue, cursor);
-                                }
-                        }
-                }
+        @Override
+        protected Object getNullValue(Interpretation<?> interpretation) {
+                return interpretation.get(Tuple.of());
         }
 
-
-        private void impactCalculation1(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues,
-                                                                        Cursor<Tuple, ?> cursor) {
-
-                Tuple tuple = cursor.getKey();
-                int o = tuple.get(0);
-                Object value = cursor.getValue();
-                long tupleHash = getTupleHash1(tuple, value, previous);
-                addHash(next, o, impactValues[0], tupleHash);
-        }
-
-        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);
-
-                Object value = cursor.getValue();
-                long tupleHash = getTupleHash2(tuple, value, previous);
-
-                addHash(next, o1, impactValues[0], tupleHash);
-                addHash(next, o2, impactValues[1], tupleHash);
-        }
-
-        private void impactCalculationN(ObjectCodeImpl previous, ObjectCodeImpl next, long[] impactValues,
-                                                                        Cursor<Tuple, ?> cursor) {
-                final Tuple tuple = cursor.getKey();
-
-                Object value = cursor.getValue();
-                long tupleHash = getTupleHashN(tuple, value, previous);
-
-                for (int i = 0; i < tuple.getSize(); i++) {
-                        addHash(next, tuple.get(i), impactValues[i], tupleHash);
-                }
+        @Override
+        protected Cursor<Tuple, ?> getCursor(Interpretation<?> interpretation) {
+                return interpretation.getAll();
         }
 }