Update exploration strategies

- Fix best first search algorithm
- Improve efficiency of exploration adapter

9 files changed, 161 insertions, 76 deletions

diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java
index 8963a496..c4aa97c2 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java
@@ -38,7 +38,9 @@ public interface DesignSpaceExplorationAdapter extends ModelAdapter {
 
         public boolean backtrack();
 
-        public Fitness calculateFitness();
+        public boolean backtrack(String reason);
+
+        public Fitness getFitness();
 
         public void newSolution();
 
@@ -63,4 +65,6 @@ public interface DesignSpaceExplorationAdapter extends ModelAdapter {
         public void setRandom(Random random);
 
         public void setRandom(long seed);
+
+        public List<Version> getSolutions();
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationStoreAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationStoreAdapter.java
index 186bfebb..0252748d 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationStoreAdapter.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationStoreAdapter.java
@@ -6,6 +6,24 @@
 package tools.refinery.store.dse;
 
 import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.store.dse.internal.TransformationRule;
+import tools.refinery.store.dse.objectives.Objective;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.dnf.RelationalQuery;
+
+import java.util.List;
+import java.util.Set;
 
 public interface DesignSpaceExplorationStoreAdapter extends ModelStoreAdapter {
+
+        @Override
+        DesignSpaceExplorationAdapter createModelAdapter(Model model);
+
+        Set<TransformationRule> getTransformationSpecifications();
+
+        Set<RelationalQuery> getGlobalConstraints();
+
+        List<Objective> getObjectives();
+
+        Strategy getStrategy();
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/Strategy.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/Strategy.java
index e240f478..409fe8a6 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/Strategy.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/Strategy.java
@@ -7,7 +7,7 @@ package tools.refinery.store.dse;
 
 public interface Strategy {
 
-        public void initStrategy(DesignSpaceExplorationAdapter designSpaceExplorationAdapter);
+        void initStrategy(DesignSpaceExplorationAdapter designSpaceExplorationAdapter);
 
-        public void explore();
+        void explore();
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java
index b32e9696..4e5cc467 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java
@@ -33,26 +33,28 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
         private final Model model;
         private final ModelQueryAdapter queryEngine;
         private final DesignSpaceExplorationStoreAdapterImpl storeAdapter;
-        private final LinkedHashSet<TransformationRule> transformationRules;
-        private final LinkedHashSet<RelationalQuery> globalConstraints;
+        private final Set<TransformationRule> transformationRules;
+        private final Set<RelationalQuery> globalConstraints;
         private final List<Objective> objectives;
         private final LinkedHashSet<ResultSet<Boolean>> globalConstraintResultSets = new LinkedHashSet<>();
         private final Interpretation<Integer> sizeInterpretation;
         private final Strategy strategy;
 
         private ObjectiveComparatorHelper objectiveComparatorHelper;
-        private List<Version> trajectory = new LinkedList<>();
+        private List<Version> trajectory = new ArrayList<>();
+        private Map<Version, Version> parents = new HashMap<>();
         private Fitness lastFitness;
-        private final LinkedHashSet<Version> solutions = new LinkedHashSet<>();
-        private Map<Version, LinkedHashSet<Activation>> statesAndUntraversedActivations;
-        private Map<Version, LinkedHashSet<Activation>> statesAndTraversedActivations;
+        private final List<Version> solutions = new ArrayList<>();
+        private Map<Version, List<Activation>> statesAndTraversedActivations;
         private Random random = new Random();
         private boolean isNewState = false;
         private final boolean isVisualizationEnabled;
         private final ModelVisualizerAdapter modelVisualizerAdapter;
 
+        private final Map<Version, Fitness> fitnessCache = new HashMap<>();
+
         public List<Version> getTrajectory() {
-                return new LinkedList<>(trajectory);
+                return new ArrayList<>(trajectory);
         }
 
         public DesignSpaceExplorationAdapterImpl(Model model, DesignSpaceExplorationStoreAdapterImpl storeAdapter) {
@@ -72,7 +74,6 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
                 }
 
                 objectives = storeAdapter.getObjectives();
-                statesAndUntraversedActivations = new HashMap<>();
                 statesAndTraversedActivations = new HashMap<>();
                 strategy = storeAdapter.getStrategy();
                 modelVisualizerAdapter = model.tryGetAdapter(ModelVisualizerAdapter.class).orElse(null);
@@ -91,11 +92,9 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
         }
 
         @Override
-        public LinkedHashSet<Version> explore() {
+        public List<Version> explore() {
                 var state = model.commit();
                 trajectory.add(state);
-                statesAndUntraversedActivations.put(state, getAllActivations());
-                statesAndTraversedActivations.put(state, new LinkedHashSet<>());
                 strategy.initStrategy(this);
                 strategy.explore();
                 return solutions;
@@ -137,14 +136,22 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
 
         @Override
         public boolean backtrack() {
+                return backtrack("");
+        }
+        @Override
+        public boolean backtrack(String reason) {
                 if (trajectory.size() < 2) {
                         return false;
                 }
+                var currentState = model.getState();
+                if (!parents.containsKey(currentState)) {
+                        return false;
+                }
                 if (isVisualizationEnabled) {
                         modelVisualizerAdapter.addTransition(trajectory.get(trajectory.size() - 1),
-                                        trajectory.get(trajectory.size() - 2), "backtrack");
+                                        trajectory.get(trajectory.size() - 2), "backtrack(" + reason + ")");
                 }
-                model.restore(trajectory.get(trajectory.size() - 2));
+                model.restore(parents.get(model.getState()));
                 trajectory.remove(trajectory.size() - 1);
                 return true;
         }
@@ -156,7 +163,7 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
 //                      modelVisualizerAdapter.addTransition(this.trajectory.get(trajectory.size() - 1),
 //                                      trajectory.get(trajectory.size() - 1), "restore");
 //              }
-                this.trajectory = trajectory;
+                this.trajectory = new ArrayList<>(trajectory);
 
         }
 
@@ -171,7 +178,18 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
         }
 
         @Override
-        public Fitness calculateFitness() {
+        public List<Version> getSolutions() {
+                return solutions;
+        }
+
+        @Override
+        public Fitness getFitness() {
+                var result = fitnessCache.computeIfAbsent(model.getState(), s -> calculateFitness());
+                lastFitness = result;
+                return result;
+        }
+
+        private Fitness calculateFitness() {
                 Fitness result = new Fitness();
                 boolean satisfiesHardObjectives = true;
                 for (Objective objective : objectives) {
@@ -203,15 +221,19 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
         }
 
         public LinkedHashSet<Activation> getUntraversedActivations() {
-//              return statesAndUntraversedActivations.get(model.getState());
-                LinkedHashSet<Activation> untraversedActivations = new LinkedHashSet<>();
-                for (Activation activation : getAllActivations()) {
-                        if (!statesAndTraversedActivations.get(model.getState()).contains(activation)) {
-                                untraversedActivations.add(activation);
+                var traversedActivations = statesAndTraversedActivations.get(model.getState());
+                if (traversedActivations == null) {
+                        return new LinkedHashSet<>(getAllActivations());
+                }
+                else {
+                        LinkedHashSet<Activation> untraversedActivations = new LinkedHashSet<>();
+                        for (Activation activation : getAllActivations()) {
+                                if (!traversedActivations.contains(activation)) {
+                                        untraversedActivations.add(activation);
+                                }
                         }
+                        return untraversedActivations;
                 }
-
-                return untraversedActivations;
         }
 
         @Override
@@ -220,26 +242,20 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
                         return false;
                 }
                 var previousState = model.getState();
-                if (!statesAndUntraversedActivations.get(previousState).contains(activation)) {
-//                      TODO: throw exception?
-                        return false;
-                }
                 if (!activation.fire()) {
                         return false;
                 }
-                statesAndUntraversedActivations.get(previousState).remove(activation);
-                statesAndTraversedActivations.get(previousState).add(activation);
+                statesAndTraversedActivations.computeIfAbsent(previousState, s -> new ArrayList<>()).add(activation);
                 var newState = model.commit();
                 trajectory.add(newState);
-                isNewState = !statesAndUntraversedActivations.containsKey(newState);
-                statesAndUntraversedActivations.put(newState, getAllActivations());
-                statesAndTraversedActivations.put(newState, new LinkedHashSet<>());
+                parents.put(newState, previousState);
+                isNewState = !statesAndTraversedActivations.containsKey(newState);
                 if (isVisualizationEnabled) {
                         if (isNewState) {
                                 modelVisualizerAdapter.addState(newState);
                         }
-                        modelVisualizerAdapter.addTransition(trajectory.get(trajectory.size() - 2),
-                                        trajectory.get(trajectory.size() - 1), activation.transformationRule().getName(),
+                        // TODO: Change to this:
+                        modelVisualizerAdapter.addTransition(previousState, newState, activation.transformationRule().getName(),
                                         activation.activation());
                 }
                 return true;
@@ -266,10 +282,10 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
                 return trajectory.contains(model.getState());
         }
 
-        public LinkedHashSet<Activation> getAllActivations() {
-                LinkedHashSet<Activation> result = new LinkedHashSet<>();
+        public List<Activation> getAllActivations() {
+                List<Activation> result = new LinkedList<>();
                 for (var rule : transformationRules) {
-                        result.addAll(rule.getAllActivations());
+                        result.addAll(rule.getAllActivationsAsList());
                 }
                 return result;
         }
@@ -279,10 +295,6 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
                 return !isNewState;
         }
 
-        public Fitness getLastFitness() {
-                return lastFitness;
-        }
-
         public ObjectiveComparatorHelper getObjectiveComparatorHelper() {
                 if (objectiveComparatorHelper == null) {
                         objectiveComparatorHelper = new ObjectiveComparatorHelper(objectives);
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationStoreAdapterImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationStoreAdapterImpl.java
index 09925ae7..fea39886 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationStoreAdapterImpl.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationStoreAdapterImpl.java
@@ -5,27 +5,26 @@
  */
 package tools.refinery.store.dse.internal;
 
-import tools.refinery.store.adapter.ModelAdapter;
-import tools.refinery.store.model.Model;
-import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.query.dnf.RelationalQuery;
 import tools.refinery.store.dse.DesignSpaceExplorationStoreAdapter;
 import tools.refinery.store.dse.Strategy;
 import tools.refinery.store.dse.objectives.Objective;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.dnf.RelationalQuery;
 
-import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Set;
 
 public class DesignSpaceExplorationStoreAdapterImpl implements DesignSpaceExplorationStoreAdapter {
         private final ModelStore store;
-        private final LinkedHashSet<TransformationRule> transformationSpecifications;
-        private final LinkedHashSet<RelationalQuery> globalConstraints;
+        private final Set<TransformationRule> transformationSpecifications;
+        private final Set<RelationalQuery> globalConstraints;
         private final List<Objective> objectives;
         private final Strategy strategy;
 
         public DesignSpaceExplorationStoreAdapterImpl(ModelStore store,
-                                                                                                  LinkedHashSet<TransformationRule> transformationSpecifications,
-                                                                                                  LinkedHashSet<RelationalQuery> globalConstraints,
+                                                                                                  Set<TransformationRule> transformationSpecifications,
+                                                                                                  Set<RelationalQuery> globalConstraints,
                                                                                                   List<Objective> objectives, Strategy strategy) {
                         this.store = store;
                         this.transformationSpecifications = transformationSpecifications;
@@ -40,22 +39,26 @@ public class DesignSpaceExplorationStoreAdapterImpl implements DesignSpaceExplor
         }
 
         @Override
-        public ModelAdapter createModelAdapter(Model model) {
+        public DesignSpaceExplorationAdapterImpl createModelAdapter(Model model) {
                 return new DesignSpaceExplorationAdapterImpl(model, this);
         }
 
-        public LinkedHashSet<TransformationRule> getTransformationSpecifications() {
+        @Override
+        public Set<TransformationRule> getTransformationSpecifications() {
                 return transformationSpecifications;
         }
 
-        public LinkedHashSet<RelationalQuery> getGlobalConstraints() {
+        @Override
+        public Set<RelationalQuery> getGlobalConstraints() {
                 return globalConstraints;
         }
 
+        @Override
         public List<Objective> getObjectives() {
                 return objectives;
         }
 
+        @Override
         public Strategy getStrategy() {
                 return strategy;
         }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java
index 015d4815..8123c0d6 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java
@@ -14,8 +14,7 @@ import tools.refinery.store.query.resultset.OrderedResultSet;
 import tools.refinery.store.query.resultset.ResultSet;
 import tools.refinery.store.tuple.Tuple;
 
-import java.util.LinkedHashSet;
-import java.util.Random;
+import java.util.*;
 
 public class TransformationRule {
 
@@ -66,11 +65,11 @@ public class TransformationRule {
                 return precondition;
         }
 
-        public ResultSet<Boolean> getAllActivationsAsSets() {
+        public ResultSet<Boolean> getAllActivationsAsResultSet() {
                 return activations;
         }
 
-        public LinkedHashSet<Activation> getAllActivations() {
+        public Set<Activation> getAllActivations() {
                 var result = new LinkedHashSet<Activation>();
                 var cursor = activations.getAll();
                 while (cursor.move()) {
@@ -79,6 +78,15 @@ public class TransformationRule {
                 return result;
         }
 
+        public List<Activation> getAllActivationsAsList() {
+                var result = new ArrayList<Activation>();
+                var cursor = activations.getAll();
+                while (cursor.move()) {
+                        result.add(new Activation(this, cursor.getKey()));
+                }
+                return result;
+        }
+
         public Activation getRandomActivation() {
                 return new Activation(this, activations.getKey(random.nextInt(activations.size())));
         }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStrategy.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStrategy.java
index 8648864c..57f86401 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStrategy.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStrategy.java
@@ -26,6 +26,7 @@ public class BestFirstStrategy implements Strategy {
         private DesignSpaceExplorationAdapter dseAdapter;
 
         private int maxDepth;
+        private int maxSolutions;
         private boolean backTrackIfSolution = true;
         private boolean onlyBetterFirst = false;
 
@@ -54,11 +55,20 @@ public class BestFirstStrategy implements Strategy {
         }
 
         public BestFirstStrategy(int maxDepth) {
+                this(maxDepth, -1);
+        }
+
+        public BestFirstStrategy(int maxDepth, int maxSolutions) {
                 if (maxDepth < 0) {
                         this.maxDepth = Integer.MAX_VALUE;
                 } else {
                         this.maxDepth = maxDepth;
                 }
+                if (maxSolutions < 0) {
+                        this.maxSolutions = Integer.MAX_VALUE;
+                } else {
+                        this.maxSolutions = maxSolutions;
+                }
         }
 
         public BestFirstStrategy continueIfHardObjectivesFulfilled() {
@@ -76,12 +86,15 @@ public class BestFirstStrategy implements Strategy {
                 this.dseAdapter = designSpaceExplorationAdapter;
                 final ObjectiveComparatorHelper objectiveComparatorHelper = dseAdapter.getObjectiveComparatorHelper();
 
-                trajectoriesToExplore = new PriorityQueue<TrajectoryWithFitness>(11,
+                trajectoriesToExplore = new PriorityQueue<>(11,
                                 (o1, o2) -> objectiveComparatorHelper.compare(o2.fitness, o1.fitness));
         }
 
         @Override
         public void explore() {
+                if (maxSolutions == 0) {
+                        return;
+                }
                 final ObjectiveComparatorHelper objectiveComparatorHelper = dseAdapter.getObjectiveComparatorHelper();
 
                 boolean globalConstraintsAreSatisfied = dseAdapter.checkGlobalConstraints();
@@ -90,7 +103,7 @@ public class BestFirstStrategy implements Strategy {
                         return;
                 }
 
-                final Fitness firstFitness = dseAdapter.calculateFitness();
+                final Fitness firstFitness = dseAdapter.getFitness();
                 if (firstFitness.isSatisfiesHardObjectives()) {
                         dseAdapter.newSolution();
                         // "First state is a solution. Terminate.");
@@ -103,9 +116,16 @@ public class BestFirstStrategy implements Strategy {
                         return;
                 }
 
-                final List<Version> firstTrajectory = dseAdapter.getTrajectory();
-                TrajectoryWithFitness currentTrajectoryWithFitness = new TrajectoryWithFitness(firstTrajectory, firstFitness);
-                trajectoriesToExplore.add(currentTrajectoryWithFitness);
+//              final List<Version> firstTrajectory = dseAdapter.getTrajectory();
+
+//              TrajectoryWithFitness currentTrajectoryWithFitness = new TrajectoryWithFitness(dseAdapter.getTrajectory(),
+//                              firstFitness);
+//              trajectoriesToExplore.add(currentTrajectoryWithFitness);
+
+
+                var firstTrajectoryWithFitness = new TrajectoryWithFitness(dseAdapter.getTrajectory(), firstFitness);
+                trajectoriesToExplore.add(firstTrajectoryWithFitness);
+                TrajectoryWithFitness currentTrajectoryWithFitness = null;
 
                 mainLoop: while (true) {
 
@@ -145,9 +165,13 @@ public class BestFirstStrategy implements Strategy {
                                         // "Global constraint is not satisfied.");
                                         dseAdapter.backtrack();
                                 } else {
-                                        final Fitness nextFitness = dseAdapter.calculateFitness();
+                                        final Fitness nextFitness = dseAdapter.getFitness();
                                         if (nextFitness.isSatisfiesHardObjectives()) {
                                                 dseAdapter.newSolution();
+                                                var solutions = dseAdapter.getSolutions().size();
+                                                if (solutions >= maxSolutions) {
+                                                        return;
+                                                }
                                                 // "Found a solution.");
                                                 if (backTrackIfSolution) {
                                                         dseAdapter.backtrack();
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/DepthFirstStrategy.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/DepthFirstStrategy.java
index 1405789b..f4a0747a 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/DepthFirstStrategy.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/DepthFirstStrategy.java
@@ -21,6 +21,7 @@ public class DepthFirstStrategy implements Strategy {
         private DesignSpaceExplorationAdapter dseAdapter;
 
         private int maxDepth;
+        private int maxSolutions;
         private boolean backTrackIfSolution = true;
 
         public DepthFirstStrategy() {
@@ -28,11 +29,20 @@ public class DepthFirstStrategy implements Strategy {
         }
 
         public DepthFirstStrategy(int maxDepth) {
+                this(maxDepth, -1);
+        }
+
+        public DepthFirstStrategy(int maxDepth, int maxSolutions) {
                 if (maxDepth < 0) {
                         this.maxDepth = Integer.MAX_VALUE;
                 } else {
                         this.maxDepth = maxDepth;
                 }
+                if (maxSolutions < 0) {
+                        this.maxSolutions = Integer.MAX_VALUE;
+                } else {
+                        this.maxSolutions = maxSolutions;
+                }
         }
 
         public DepthFirstStrategy continueIfHardObjectivesFulfilled() {
@@ -47,6 +57,9 @@ public class DepthFirstStrategy implements Strategy {
 
         @Override
         public void explore() {
+                if (maxSolutions == 0) {
+                        return;
+                }
                 mainloop: while (true) {
                         var globalConstraintsAreSatisfied = dseAdapter.checkGlobalConstraints();
                         if (!globalConstraintsAreSatisfied) {
@@ -61,9 +74,13 @@ public class DepthFirstStrategy implements Strategy {
                                 }
                         }
 
-                        Fitness fitness = dseAdapter.calculateFitness();
+                        Fitness fitness = dseAdapter.getFitness();
                         if (fitness.isSatisfiesHardObjectives()) {
                                 dseAdapter.newSolution();
+                                var solutions = dseAdapter.getSolutions().size();
+                                if (solutions >= maxSolutions) {
+                                        return;
+                                }
                                 if (backTrackIfSolution) {
                                         var isSuccessfulUndo = dseAdapter.backtrack();
                                         if (!isSuccessfulUndo) {
@@ -76,7 +93,6 @@ public class DepthFirstStrategy implements Strategy {
                                 }
                         }
 
-                        var depth = dseAdapter.getDepth();
                         if (dseAdapter.getDepth() >= maxDepth) {
                                 var isSuccessfulUndo = dseAdapter.backtrack();
                                 if (!isSuccessfulUndo) {
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java
index 312bcebd..f57f68ef 100644
--- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java
@@ -137,8 +137,8 @@ public class TransformationRuleTest {
 
                 queryEngine.flushChanges();
 
-                var assignFeatureRuleActivations = assignFeatureRule.getAllActivationsAsSets();
-                var deleteEmptyClassRuleActivations = deleteEmptyClassRule.getAllActivationsAsSets();
+                var assignFeatureRuleActivations = assignFeatureRule.getAllActivationsAsResultSet();
+                var deleteEmptyClassRuleActivations = deleteEmptyClassRule.getAllActivationsAsResultSet();
 
                 assertResults(Map.of(
                                 Tuple.of(newClass1Id, newFieldId), true,
@@ -236,12 +236,12 @@ public class TransformationRuleTest {
                 assertResults(Map.of(
                                 Tuple.of(newModelId, newClass1Id), true,
                                 Tuple.of(newModelId, newClass2Id), true
-                ), deleteEmptyClassRule0.getAllActivationsAsSets());
+                ), deleteEmptyClassRule0.getAllActivationsAsResultSet());
 
                 assertResults(Map.of(
                                 Tuple.of(newModelId, newClass1Id), true,
                                 Tuple.of(newModelId, newClass2Id), true
-                ), deleteEmptyClassRule1.getAllActivationsAsSets());
+                ), deleteEmptyClassRule1.getAllActivationsAsResultSet());
 
                 assertEquals(Tuple.of(newModelId, newClass2Id), activation0);
                 assertEquals(Tuple.of(newModelId, newClass1Id), activation1);
@@ -312,7 +312,7 @@ public class TransformationRuleTest {
                 assertResults(Map.of(
                                 Tuple.of(newModelId, newClass1Id), true,
                                 Tuple.of(newModelId, newClass2Id), true
-                ), deleteEmptyClassRule.getAllActivationsAsSets());
+                ), deleteEmptyClassRule.getAllActivationsAsResultSet());
 
 
                 deleteEmptyClassRule.fireActivation(Tuple.of(0, 1));
@@ -320,7 +320,7 @@ public class TransformationRuleTest {
                 assertResults(Map.of(
                                 Tuple.of(newModelId, newClass1Id), false,
                                 Tuple.of(newModelId, newClass2Id), true
-                ), deleteEmptyClassRule.getAllActivationsAsSets());
+                ), deleteEmptyClassRule.getAllActivationsAsResultSet());
         }
 
         @Test
@@ -388,21 +388,21 @@ public class TransformationRuleTest {
                 assertResults(Map.of(
                                 Tuple.of(newModelId, newClass1Id), true,
                                 Tuple.of(newModelId, newClass2Id), true
-                ), deleteEmptyClassRule.getAllActivationsAsSets());
+                ), deleteEmptyClassRule.getAllActivationsAsResultSet());
 
                 deleteEmptyClassRule.fireRandomActivation();
 
                 assertResults(Map.of(
                                 Tuple.of(newModelId, newClass1Id), true,
                                 Tuple.of(newModelId, newClass2Id), false
-                ), deleteEmptyClassRule.getAllActivationsAsSets());
+                ), deleteEmptyClassRule.getAllActivationsAsResultSet());
 
                 deleteEmptyClassRule.fireRandomActivation();
 
                 assertResults(Map.of(
                                 Tuple.of(newModelId, newClass1Id), false,
                                 Tuple.of(newModelId, newClass2Id), false
-                ), deleteEmptyClassRule.getAllActivationsAsSets());
+                ), deleteEmptyClassRule.getAllActivationsAsResultSet());
 
         }
 }