Add Design space exploration and DFS strategy

- Transformation rules
- Design Space Exploration adapter
- Depth First Strategy

22 files changed, 1944 insertions, 3 deletions

diff --git a/subprojects/store-query-viatra/build.gradle.kts b/subprojects/store-query-viatra/build.gradle.kts
index e3a22145..85ea7e2e 100644
--- a/subprojects/store-query-viatra/build.gradle.kts
+++ b/subprojects/store-query-viatra/build.gradle.kts
@@ -12,4 +12,5 @@ dependencies {
         implementation(libs.ecore)
         api(libs.viatra)
         api(project(":refinery-store-query"))
+        api(project(":refinery-store-reasoning"))
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/ActionFactory.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/ActionFactory.java
new file mode 100644
index 00000000..e2f452c3
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/ActionFactory.java
@@ -0,0 +1,9 @@
+package tools.refinery.store.query.dse;
+
+import org.eclipse.collections.api.block.procedure.Procedure;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+
+public interface ActionFactory {
+        Procedure<Tuple> prepare(Model model);
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/DesignSpaceExplorationAdapter.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/DesignSpaceExplorationAdapter.java
new file mode 100644
index 00000000..e7ce7b2c
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/DesignSpaceExplorationAdapter.java
@@ -0,0 +1,55 @@
+package tools.refinery.store.query.dse;
+
+import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.query.dse.internal.Activation;
+import tools.refinery.store.query.dse.internal.DesignSpaceExplorationBuilderImpl;
+import tools.refinery.store.query.dse.objectives.Fitness;
+import tools.refinery.store.query.dse.objectives.ObjectiveComparatorHelper;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple1;
+
+import java.util.Collection;
+import java.util.List;
+
+public interface DesignSpaceExplorationAdapter extends ModelAdapter {
+        @Override
+        DesignSpaceExplorationStoreAdapter getStoreAdapter();
+
+        static DesignSpaceExplorationBuilder builder() {
+                return new DesignSpaceExplorationBuilderImpl();
+        }
+
+        Collection<Long> explore();
+
+        public int getModelSize();
+
+        public Tuple1 createObject();
+
+        public Tuple deleteObject(Tuple tuple);
+
+        public boolean checkGlobalConstraints();
+
+        public boolean backtrack();
+
+        public Fitness calculateFitness();
+
+        public void newSolution();
+
+        public int getDepth();
+
+        public Collection<Activation> getUntraversedActivations();
+
+        public boolean fireActivation(Activation activation);
+
+        public void fireRandomActivation();
+
+        public boolean isCurrentInTrajectory();
+
+        public List<Long> getTrajectory();
+
+        public boolean isCurrentStateAlreadyTraversed();
+
+        public ObjectiveComparatorHelper getObjectiveComparatorHelper();
+
+        public void restoreTrajectory(List<Long>  trajectory);
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/DesignSpaceExplorationBuilder.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/DesignSpaceExplorationBuilder.java
new file mode 100644
index 00000000..0ec6f599
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/DesignSpaceExplorationBuilder.java
@@ -0,0 +1,55 @@
+package tools.refinery.store.query.dse;
+
+import tools.refinery.store.adapter.ModelAdapterBuilder;
+import tools.refinery.store.query.dnf.AnyQuery;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.dse.internal.TransformationRule;
+import tools.refinery.store.query.dse.objectives.Objective;
+
+import java.util.Collection;
+import java.util.List;
+
+public interface DesignSpaceExplorationBuilder extends ModelAdapterBuilder {
+        default DesignSpaceExplorationBuilder stopConditions(AnyQuery... stopConditions) {
+                return stopConditions(List.of(stopConditions));
+        }
+
+        default DesignSpaceExplorationBuilder stopConditions(Collection<? extends AnyQuery> stopConditions) {
+                stopConditions.forEach(this::stopCondition);
+                return this;
+        }
+
+        default DesignSpaceExplorationBuilder transformations(TransformationRule... transformationRules) {
+                return transformations(List.of(transformationRules));
+        }
+
+        default DesignSpaceExplorationBuilder transformations(Collection<? extends TransformationRule> transformationRules) {
+                transformationRules.forEach(this::transformation);
+                return this;
+        }
+
+        default DesignSpaceExplorationBuilder globalConstraints(RelationalQuery... globalConstraints) {
+                return globalConstraints(List.of(globalConstraints));
+        }
+
+        default DesignSpaceExplorationBuilder globalConstraints(Collection<RelationalQuery> globalConstraints) {
+                globalConstraints.forEach(this::globalConstraint);
+                return this;
+        }
+
+        default DesignSpaceExplorationBuilder objectives(Objective... objectives) {
+                return objectives(List.of(objectives));
+        }
+
+        default DesignSpaceExplorationBuilder objectives(Collection<? extends Objective> objectives) {
+                objectives.forEach(this::objective);
+                return this;
+        }
+
+        DesignSpaceExplorationBuilder stopCondition(AnyQuery stopCondition);
+
+        DesignSpaceExplorationBuilder transformation(TransformationRule transformationRule);
+        DesignSpaceExplorationBuilder globalConstraint(RelationalQuery globalConstraint);
+        DesignSpaceExplorationBuilder objective(Objective objective);
+        DesignSpaceExplorationBuilder strategy(Strategy strategy);
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/DesignSpaceExplorationStoreAdapter.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/DesignSpaceExplorationStoreAdapter.java
new file mode 100644
index 00000000..21b10f0e
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/DesignSpaceExplorationStoreAdapter.java
@@ -0,0 +1,6 @@
+package tools.refinery.store.query.dse;
+
+import tools.refinery.store.adapter.ModelStoreAdapter;
+
+public interface DesignSpaceExplorationStoreAdapter extends ModelStoreAdapter {
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/Strategy.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/Strategy.java
new file mode 100644
index 00000000..0aeea818
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/Strategy.java
@@ -0,0 +1,10 @@
+package tools.refinery.store.query.dse;

+

+import tools.refinery.store.model.Model;

+

+public interface Strategy {

+

+        public void initStrategy(DesignSpaceExplorationAdapter designSpaceExplorationAdapter);

+

+        public void explore();

+}

diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/Activation.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/Activation.java
new file mode 100644
index 00000000..82a4c978
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/Activation.java
@@ -0,0 +1,9 @@
+package tools.refinery.store.query.dse.internal;
+
+import tools.refinery.store.tuple.Tuple;
+
+public record Activation(TransformationRule transformationRule, Tuple activation) {
+        public boolean fire() {
+                return transformationRule.fireActivation(activation);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/DesignSpaceExplorationAdapterImpl.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/DesignSpaceExplorationAdapterImpl.java
new file mode 100644
index 00000000..5adf8306
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/DesignSpaceExplorationAdapterImpl.java
@@ -0,0 +1,256 @@
+package tools.refinery.store.query.dse.internal;
+
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.dse.DesignSpaceExplorationAdapter;
+import tools.refinery.store.query.dse.DesignSpaceExplorationStoreAdapter;
+import tools.refinery.store.query.dse.Strategy;
+import tools.refinery.store.query.dse.objectives.Fitness;
+import tools.refinery.store.query.dse.objectives.LeveledObjectivesHelper;
+import tools.refinery.store.query.dse.objectives.Objective;
+import tools.refinery.store.query.dse.objectives.ObjectiveComparatorHelper;
+import tools.refinery.store.query.resultset.ResultSet;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple1;
+
+import java.util.*;
+
+public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExplorationAdapter {
+        static final Symbol<Integer> NODE_COUNT_SYMBOL = Symbol.of("MODEL_SIZE", 0, Integer.class, 0);
+        private final Model model;
+        private final ModelQueryAdapter queryEngine;
+        private final DesignSpaceExplorationStoreAdapterImpl storeAdapter;
+        private final Set<TransformationRule> transformationRules;
+        private final Set<RelationalQuery> globalConstraints;
+        private final List<Objective> objectives;
+        private final Set<ResultSet<Boolean>> globalConstraintResultSets = new HashSet<>();
+        private final Interpretation<Integer> sizeInterpretation;
+        private final Strategy strategy;
+
+        private ObjectiveComparatorHelper objectiveComparatorHelper;
+        private List<Long> trajectory = new LinkedList<>();
+        private Fitness lastFitness;
+        private final Set<Long> solutions = new HashSet<>();
+//      private Map<Long, Collection<Activation>> statesAndActivations;
+        private Map<Long, Collection<Activation>> statesAndUntraversedActivations;
+        private Map<Long, Collection<Activation>> statesAndTraversedActivations;
+        private Random random = new Random();
+        private Objective[][] leveledObjectives;
+        private boolean isNewState = false;
+
+        public List<Long> getTrajectory() {
+                return trajectory;
+        }
+
+        public DesignSpaceExplorationAdapterImpl(Model model, DesignSpaceExplorationStoreAdapterImpl storeAdapter) {
+                this.model = model;
+                this.storeAdapter = storeAdapter;
+                this.sizeInterpretation = model.getInterpretation(NODE_COUNT_SYMBOL);
+                queryEngine = model.getAdapter(ModelQueryAdapter.class);
+
+                globalConstraints = storeAdapter.getGlobalConstraints();
+                for (var constraint : globalConstraints) {
+                        globalConstraintResultSets.add(queryEngine.getResultSet(constraint));
+                }
+
+                transformationRules = storeAdapter.getTransformationSpecifications();
+                for (var rule : transformationRules) {
+                        rule.prepare(model, queryEngine);
+                }
+
+                objectives = storeAdapter.getObjectives();
+                leveledObjectives = new LeveledObjectivesHelper(objectives).initLeveledObjectives();
+                statesAndUntraversedActivations = new HashMap<>();
+                statesAndTraversedActivations = new HashMap<>();
+                strategy = storeAdapter.getStrategy();
+
+        }
+
+        @Override
+        public Model getModel() {
+                return model;
+        }
+
+        @Override
+        public DesignSpaceExplorationStoreAdapter getStoreAdapter() {
+                return storeAdapter;
+        }
+
+        @Override
+        public Collection<Long> explore() {
+                var state = model.commit();
+                trajectory.add(state);
+                statesAndUntraversedActivations.put(state, getAllActivations());
+                statesAndTraversedActivations.put(state, new HashSet<>());
+                strategy.initStrategy(this);
+                strategy.explore();
+                return solutions;
+        }
+
+        @Override
+        public int getModelSize() {
+                return sizeInterpretation.get(Tuple.of());
+        }
+
+        @Override
+        public Tuple1 createObject() {
+                var newNodeId =  getModelSize();
+                sizeInterpretation.put(Tuple.of(), newNodeId + 1);
+                return Tuple.of(newNodeId);
+        }
+
+        @Override
+        public Tuple deleteObject(Tuple tuple) {
+                if (tuple.getSize() != 1) {
+                        throw new IllegalArgumentException("Tuple size must be 1");
+                }
+//              TODO: implement more efficient deletion
+//              if (tuple.get(0) == getModelSize() - 1) {
+//                      sizeInterpretation.put(Tuple.of(), getModelSize() - 1);
+//              }
+                return tuple;
+        }
+
+        @Override
+        public boolean checkGlobalConstraints() {
+                for (var resultSet : globalConstraintResultSets) {
+                        if (resultSet.size() > 0) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+
+        @Override
+        public boolean backtrack() {
+                if (trajectory.size() < 2) {
+                        return false;
+                }
+                model.restore(trajectory.get(trajectory.size() - 2));
+                trajectory.remove(trajectory.size() - 1);
+                return true;
+        }
+
+        @Override
+        public void restoreTrajectory(List<Long> trajectory) {
+                model.restore(trajectory.get(trajectory.size() - 1));
+                this.trajectory = trajectory;
+
+        }
+
+        @Override
+        public Fitness calculateFitness() {
+                Fitness result = new Fitness();
+                boolean satisfiesHardObjectives = true;
+                for (Objective objective : objectives) {
+                        var fitness = objective.getFitness(this);
+                        result.put(objective.getName(), fitness);
+                        if (objective.isHardObjective() && !objective.satisfiesHardObjective(fitness)) {
+                                satisfiesHardObjectives = false;
+                        }
+                }
+                result.setSatisfiesHardObjectives(satisfiesHardObjectives);
+
+                lastFitness = result;
+
+                return result;
+        }
+
+        @Override
+        public void newSolution() {
+                var state = model.getState();
+                solutions.add(state);
+        }
+
+        @Override
+        public int getDepth() {
+                return trajectory.size() - 1;
+        }
+
+        public Collection<Activation> getUntraversedActivations() {
+//              return statesAndUntraversedActivations.get(model.getState());
+                List<Activation> untraversedActivations = new ArrayList<>();
+                for (Activation activation : getAllActivations()) {
+                        if (!statesAndTraversedActivations.get(model.getState()).contains(activation)) {
+                                untraversedActivations.add(activation);
+                        }
+                }
+
+                return untraversedActivations;
+        }
+
+        @Override
+        public boolean fireActivation(Activation activation) {
+                if (activation == null) {
+                        return false;
+                }
+                long 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);
+                long newState = model.commit();
+                trajectory.add(newState);
+                isNewState = !statesAndUntraversedActivations.containsKey(newState);
+                statesAndUntraversedActivations.put(newState, getAllActivations());
+                statesAndTraversedActivations.put(newState, new HashSet<>());
+                return true;
+        }
+
+        @Override
+        public void fireRandomActivation() {
+                var activations = getUntraversedActivations();
+                if (activations.isEmpty()) {
+//                      TODO: throw exception
+                        return;
+                }
+                int index = random.nextInt(activations.size());
+                var iterator = activations.iterator();
+                while (index-- > 0) {
+                        iterator.next();
+                }
+                var activationId = iterator.next();
+                fireActivation(activationId);
+        }
+
+        @Override
+        public boolean isCurrentInTrajectory() {
+                return trajectory.contains(model.getState());
+        }
+
+        public Collection<Activation> getAllActivations() {
+                Collection<Activation> result = new HashSet<>();
+                for (var rule : transformationRules) {
+                        result.addAll(rule.getAllActivations());
+                }
+                return result;
+        }
+
+        public boolean isCurrentStateAlreadyTraversed() {
+//              TODO: check isomorphism?
+                return !isNewState;
+        }
+
+        public Fitness getLastFitness() {
+                return lastFitness;
+        }
+
+        public ObjectiveComparatorHelper getObjectiveComparatorHelper() {
+                if (objectiveComparatorHelper == null) {
+                        objectiveComparatorHelper = new ObjectiveComparatorHelper(leveledObjectives);
+                }
+                return objectiveComparatorHelper;
+        }
+
+        public Objective[][] getLeveledObjectives() {
+                return leveledObjectives;
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/DesignSpaceExplorationBuilderImpl.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/DesignSpaceExplorationBuilderImpl.java
new file mode 100644
index 00000000..79864de0
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/DesignSpaceExplorationBuilderImpl.java
@@ -0,0 +1,77 @@
+package tools.refinery.store.query.dse.internal;
+
+import tools.refinery.store.adapter.AbstractModelAdapterBuilder;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.query.dnf.AnyQuery;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.dse.DesignSpaceExplorationBuilder;
+import tools.refinery.store.query.dse.Strategy;
+import tools.refinery.store.query.dse.objectives.Objective;
+
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+public class DesignSpaceExplorationBuilderImpl
+                extends AbstractModelAdapterBuilder<DesignSpaceExplorationStoreAdapterImpl>
+                implements DesignSpaceExplorationBuilder {
+
+        private final Set<AnyQuery> stopConditionSpecifications = new LinkedHashSet<>();
+        private final Set<TransformationRule> transformationSpecifications = new LinkedHashSet<>();
+        private final Set<RelationalQuery> globalConstraints = new LinkedHashSet<>();
+        private final List<Objective> objectives = new LinkedList<>();
+        private Strategy strategy;
+
+        @Override
+        protected DesignSpaceExplorationStoreAdapterImpl doBuild(ModelStore store) {
+                return new DesignSpaceExplorationStoreAdapterImpl(store, stopConditionSpecifications,
+                                transformationSpecifications, globalConstraints, objectives, strategy);
+        }
+
+        @Override
+        public DesignSpaceExplorationBuilder stopCondition(AnyQuery stopCondition) {
+                checkNotConfigured();
+                stopConditionSpecifications.add(stopCondition);
+                return this;
+        }
+
+        @Override
+        public DesignSpaceExplorationBuilder transformation(TransformationRule transformationRule) {
+                checkNotConfigured();
+                transformationSpecifications.add(transformationRule);
+                return this;
+        }
+
+        @Override
+        public DesignSpaceExplorationBuilder globalConstraint(RelationalQuery globalConstraint) {
+                checkNotConfigured();
+                globalConstraints.add(globalConstraint);
+                return this;
+        }
+
+        @Override
+        public DesignSpaceExplorationBuilder objective(Objective objective) {
+                checkNotConfigured();
+                objectives.add(objective);
+                return this;
+        }
+
+        @Override
+        public DesignSpaceExplorationBuilder strategy(Strategy strategy) {
+                checkNotConfigured();
+                this.strategy = strategy;
+                return this;
+        }
+
+        public Set<AnyQuery> getStopConditionSpecifications() {
+                return stopConditionSpecifications;
+        }
+
+        @Override
+        protected void doConfigure(ModelStoreBuilder storeBuilder) {
+                storeBuilder.symbols(DesignSpaceExplorationAdapterImpl.NODE_COUNT_SYMBOL);
+                super.doConfigure(storeBuilder);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/DesignSpaceExplorationStoreAdapterImpl.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/DesignSpaceExplorationStoreAdapterImpl.java
new file mode 100644
index 00000000..9c2fa4d6
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/DesignSpaceExplorationStoreAdapterImpl.java
@@ -0,0 +1,64 @@
+package tools.refinery.store.query.dse.internal;
+
+import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.query.dnf.AnyQuery;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.dse.DesignSpaceExplorationStoreAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.dse.Strategy;
+import tools.refinery.store.query.dse.objectives.Objective;
+
+import java.util.List;
+import java.util.Set;
+
+public class DesignSpaceExplorationStoreAdapterImpl implements DesignSpaceExplorationStoreAdapter {
+        private final ModelStore store;
+        private final Set<AnyQuery> stopConditionSpecifications;
+        private final Set<TransformationRule> transformationSpecifications;
+        private final Set<RelationalQuery> globalConstraints;
+        private final List<Objective> objectives;
+        private final Strategy strategy;
+
+        public DesignSpaceExplorationStoreAdapterImpl(ModelStore store, Set<AnyQuery> stopConditionSpecifications,
+                                                                                                  Set<TransformationRule> transformationSpecifications,
+                                                                                                  Set<RelationalQuery> globalConstraints, List<Objective> objectives,
+                                Strategy strategy) {
+                        this.store = store;
+                        this.stopConditionSpecifications = stopConditionSpecifications;
+                        this.transformationSpecifications = transformationSpecifications;
+                        this.globalConstraints = globalConstraints;
+                        this.objectives = objectives;
+                        this.strategy = strategy;
+        }
+
+        @Override
+        public ModelStore getStore() {
+                return store;
+        }
+
+        @Override
+        public ModelAdapter createModelAdapter(Model model) {
+                return new DesignSpaceExplorationAdapterImpl(model, this);
+        }
+
+        public Set<AnyQuery> getStopConditionSpecifications() {
+                return stopConditionSpecifications;
+        }
+
+        public Set<TransformationRule> getTransformationSpecifications() {
+                return transformationSpecifications;
+        }
+
+        public Set<RelationalQuery> getGlobalConstraints() {
+                return globalConstraints;
+        }
+
+        public List<Objective> getObjectives() {
+                return objectives;
+        }
+
+        public Strategy getStrategy() {
+                return strategy;
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/TransformationRule.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/TransformationRule.java
new file mode 100644
index 00000000..c46ff712
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/internal/TransformationRule.java
@@ -0,0 +1,85 @@
+package tools.refinery.store.query.dse.internal;
+
+import org.eclipse.collections.api.block.procedure.Procedure;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.dse.ActionFactory;
+import tools.refinery.store.query.resultset.OrderedResultSet;
+import tools.refinery.store.query.resultset.ResultSet;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.HashSet;
+import java.util.Random;
+import java.util.Set;
+
+public class TransformationRule {
+
+        private final String name;
+        private final RelationalQuery precondition;
+        private final ActionFactory actionFactory;
+        private Procedure<Tuple> action;
+        private OrderedResultSet<Boolean> activations;
+        private Random random;
+        private ModelQueryAdapter queryEngine;
+
+        public TransformationRule(String name, RelationalQuery precondition, ActionFactory actionFactory) {
+                this(name, precondition, actionFactory, new Random());
+        }
+
+        public TransformationRule(String name, RelationalQuery precondition, ActionFactory actionFactory, long seed) {
+                this(name, precondition, actionFactory, new Random(seed));
+        }
+
+        public TransformationRule(String name, RelationalQuery precondition, ActionFactory actionFactory, Random random) {
+                this.name = name;
+                this.precondition = precondition;
+                this.actionFactory = actionFactory;
+                this.random = random;
+        }
+        public boolean prepare(Model model, ModelQueryAdapter queryEngine) {
+                action = actionFactory.prepare(model);
+                this.queryEngine = queryEngine;
+                activations = new OrderedResultSet<>(queryEngine.getResultSet(precondition));
+                return true;
+        }
+
+        public boolean fireActivation(Tuple activation) {
+                action.accept(activation);
+                queryEngine.flushChanges();
+                return true;
+        }
+
+        public boolean fireRandomActivation() {
+                return getRandomActivation().fire();
+        }
+
+        public String getName() {
+                return name;
+        }
+
+        public RelationalQuery getPrecondition() {
+                return precondition;
+        }
+
+        public ResultSet<Boolean> getAllActivationsAsSets() {
+                return activations;
+        }
+
+        public Set<Activation> getAllActivations() {
+                var result = new HashSet<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())));
+        }
+
+        public Activation getActivation(int index) {
+                return new Activation(this, activations.getKey(index));
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/AlwaysSatisfiedDummyHardObjective.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/AlwaysSatisfiedDummyHardObjective.java
new file mode 100644
index 00000000..26744d94
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/AlwaysSatisfiedDummyHardObjective.java
@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.store.query.dse.objectives;
+
+import tools.refinery.store.query.dse.DesignSpaceExplorationAdapter;
+
+/**
+ * This hard objective is fulfilled in any circumstances. Use it if all states should be regarded as a valid solution.
+ *
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public class AlwaysSatisfiedDummyHardObjective extends BaseObjective {
+
+        private static final String DEFAULT_NAME = "AlwaysSatisfiedDummyHardObjective";
+
+        public AlwaysSatisfiedDummyHardObjective() {
+                super(DEFAULT_NAME);
+        }
+
+        public AlwaysSatisfiedDummyHardObjective(String name) {
+                super(name);
+        }
+
+        @Override
+        public Double getFitness(DesignSpaceExplorationAdapter context) {
+                return 0d;
+        }
+
+        @Override
+        public boolean isHardObjective() {
+                return true;
+        }
+
+        @Override
+        public boolean satisfiesHardObjective(Double fitness) {
+                return true;
+        }
+
+        @Override
+        public Objective createNew() {
+                return this;
+        }
+
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/BaseObjective.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/BaseObjective.java
new file mode 100644
index 00000000..fd8529f7
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/BaseObjective.java
@@ -0,0 +1,147 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.store.query.dse.objectives;
+
+import tools.refinery.store.query.dse.DesignSpaceExplorationAdapter;
+
+import java.util.Comparator;
+import java.util.Objects;
+
+/**
+ * This abstract class implements the basic functionality of an objective ({@link Objective} namely its name,
+ * comparator, level and fitness hard constraint.
+ *
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public abstract class BaseObjective implements Objective {
+
+        protected final String name;
+        protected Comparator<Double> comparator = Comparators.HIGHER_IS_BETTER;
+        protected int level = 0;
+
+        protected double fitnessConstraint;
+        protected boolean isThereFitnessConstraint = false;
+        protected Comparator<Double> fitnessConstraintComparator;
+
+        public BaseObjective(String name) {
+                Objects.requireNonNull(name, "Name of the objective cannot be null.");
+                this.name = name;
+        }
+
+        @Override
+        public String getName() {
+                return name;
+        }
+
+        @Override
+        public void setComparator(Comparator<Double> comparator) {
+                this.comparator = comparator;
+        }
+
+        @Override
+        public Comparator<Double> getComparator() {
+                return comparator;
+        }
+
+        @Override
+        public void setLevel(int level) {
+                this.level = level;
+        }
+
+        @Override
+        public int getLevel() {
+                return level;
+        }
+
+        public BaseObjective withLevel(int level) {
+                setLevel(level);
+                return this;
+        }
+
+        public BaseObjective withComparator(Comparator<Double> comparator) {
+                setComparator(comparator);
+                return this;
+        }
+
+        /**
+         * Adds a hard constraint on the fitness value. For example, the fitness value must be better than 10 to accept the
+         * current state as a solution.
+         *
+         * @param fitnessConstraint
+         *            Solutions should be better than this value.
+         * @param fitnessConstraintComparator
+         *            {@link Comparator} to determine if the current state is better than the given value.
+         * @return The actual instance to enable builder pattern like usage.
+         */
+        public BaseObjective withHardConstraintOnFitness(double fitnessConstraint,
+                                                                                                         Comparator<Double> fitnessConstraintComparator) {
+                this.fitnessConstraint = fitnessConstraint;
+                this.fitnessConstraintComparator = fitnessConstraintComparator;
+                this.isThereFitnessConstraint = true;
+                return this;
+        }
+
+        /**
+         * Adds a hard constraint on the fitness value. For example, the fitness value must be better than 10 to accept the
+         * current state as a solution. The provided comparator will be used.
+         *
+         * @param fitnessConstraint
+         *            Solutions should be better than this value.
+         * @return The actual instance to enable builder pattern like usage.
+         */
+        public BaseObjective withHardConstraintOnFitness(double fitnessConstraint) {
+                return withHardConstraintOnFitness(fitnessConstraint, null);
+        }
+
+        @Override
+        public void init(DesignSpaceExplorationAdapter context) {
+                if (fitnessConstraintComparator == null) {
+                        fitnessConstraintComparator = comparator;
+                }
+        }
+
+        @Override
+        public boolean isHardObjective() {
+                return isThereFitnessConstraint;
+        }
+
+        @Override
+        public boolean satisfiesHardObjective(Double fitness) {
+                if (isThereFitnessConstraint) {
+                        int compare = fitnessConstraintComparator.compare(fitness, fitnessConstraint);
+                        if (compare < 0) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+
+        @Override
+        public int hashCode() {
+                return name.hashCode();
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (this == obj) {
+                        return true;
+                }
+                if (obj instanceof BaseObjective baseObjective) {
+                        return name.equals(baseObjective.getName());
+                }
+                return false;
+        }
+
+        @Override
+        public String toString() {
+                return name;
+        }
+
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/Comparators.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/Comparators.java
new file mode 100644
index 00000000..7fba6736
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/Comparators.java
@@ -0,0 +1,25 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.store.query.dse.objectives;
+
+import java.util.Comparator;
+
+public class Comparators {
+
+        private Comparators() { /*Utility class constructor*/ }
+
+        public static final Comparator<Double> HIGHER_IS_BETTER = (o1, o2) -> o1.compareTo(o2);
+
+        public static final Comparator<Double> LOWER_IS_BETTER = (o1, o2) -> o2.compareTo(o1);
+
+        private static final Double ZERO = (double) 0;
+
+        public static final Comparator<Double> DIFFERENCE_TO_ZERO_IS_BETTER = (o1, o2) -> ZERO.compareTo(Math.abs(o1)-Math.abs(o2));
+
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/Fitness.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/Fitness.java
new file mode 100644
index 00000000..ea80ed55
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/Fitness.java
@@ -0,0 +1,21 @@
+package tools.refinery.store.query.dse.objectives;
+
+import java.util.HashMap;
+
+public class Fitness extends HashMap<String, Double> {
+
+        private boolean satisfiesHardObjectives;
+
+        public boolean isSatisfiesHardObjectives() {
+                return satisfiesHardObjectives;
+        }
+
+        public void setSatisfiesHardObjectives(boolean satisfiesHardObjectives) {
+                this.satisfiesHardObjectives = satisfiesHardObjectives;
+        }
+
+        @Override
+        public String toString() {
+                return super.toString() + " hardObjectives=" + satisfiesHardObjectives;
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/LeveledObjectivesHelper.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/LeveledObjectivesHelper.java
new file mode 100644
index 00000000..6c4e7837
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/LeveledObjectivesHelper.java
@@ -0,0 +1,114 @@
+/*******************************************************************************

+ * Copyright (c) 2010-2016, Andras Szabolcs Nagy and Daniel Varro

+ * This program and the accompanying materials are made available under the

+ * terms of the Eclipse Public License v. 2.0 which is available at

+ * http://www.eclipse.org/legal/epl-v20.html.

+ *

+ * SPDX-License-Identifier: EPL-2.0

+ *******************************************************************************/

+package tools.refinery.store.query.dse.objectives;

+

+import java.util.ArrayList;

+import java.util.Arrays;

+import java.util.Comparator;

+import java.util.List;

+

+public class LeveledObjectivesHelper {

+

+        private List<Objective> objectives = new ArrayList<Objective>();

+        private Objective[][] leveledObjectives;

+

+        public LeveledObjectivesHelper(List<Objective> objectives) {

+                this.objectives = objectives;

+        }

+

+        public Objective[][] initLeveledObjectives() {

+                if (objectives.isEmpty()) {

+                        leveledObjectives = new Objective[0][0];

+                        return leveledObjectives;

+                }

+

+                int level = objectives.get(0).getLevel();

+                boolean oneLevelOnly = true;

+                for (Objective objective : objectives) {

+                        if (objective.getLevel() != level) {

+                                oneLevelOnly = false;

+                                break;

+                        }

+                }

+

+                if (oneLevelOnly) {

+                        leveledObjectives = new Objective[1][objectives.size()];

+                        for (int i = 0; i < objectives.size(); i++) {

+                                leveledObjectives[0][i] = objectives.get(i);

+                        }

+                        return leveledObjectives;

+                }

+

+                Objective[] objectivesArray = getSortedByLevelObjectives(objectives);

+

+                int numberOfLevels = getNumberOfObjectiveLevels(objectivesArray);

+

+                leveledObjectives = new Objective[numberOfLevels][];

+

+                fillLeveledObjectives(objectivesArray);

+

+                return leveledObjectives;

+        }

+

+        private void fillLeveledObjectives(Objective[] objectivesArray) {

+                int actLevel = objectivesArray[0].getLevel();

+                int levelIndex = 0;

+                int lastIndex = 0;

+                int corrigationForLastLevel = 0;

+                boolean oneObjectiveAtLastLevel = false;

+                for (int i = 0; i < objectivesArray.length; i++) {

+                        if (i == objectivesArray.length - 1) {

+                                corrigationForLastLevel = 1;

+                                if (objectivesArray[i - 1].getLevel() != objectivesArray[i].getLevel()) {

+                                        oneObjectiveAtLastLevel = true;

+                                        corrigationForLastLevel = 0;

+                                }

+                        }

+                        if (objectivesArray[i].getLevel() != actLevel || corrigationForLastLevel == 1 || oneObjectiveAtLastLevel) {

+                                leveledObjectives[levelIndex] = new Objective[i - lastIndex + corrigationForLastLevel];

+                                for (int j = lastIndex; j < i + corrigationForLastLevel; j++) {

+                                        leveledObjectives[levelIndex][j - lastIndex] = objectivesArray[j];

+                                }

+                                if (oneObjectiveAtLastLevel) {

+                                        leveledObjectives[levelIndex + 1] = new Objective[1];

+                                        leveledObjectives[levelIndex + 1][0] = objectivesArray[i];

+                                }

+                                actLevel = objectivesArray[i].getLevel();

+                                levelIndex++;

+                                lastIndex = i;

+                        }

+                }

+        }

+

+        private int getNumberOfObjectiveLevels(Objective[] objectivesArray) {

+

+                int actLevel = objectivesArray[0].getLevel();

+                int numberOfLevels = 1;

+

+                for (int i = 1; i < objectivesArray.length; i++) {

+                        if (objectivesArray[i].getLevel() != actLevel) {

+                                numberOfLevels++;

+                                actLevel = objectivesArray[i].getLevel();

+                        }

+                }

+

+                return numberOfLevels;

+        }

+

+        private Objective[] getSortedByLevelObjectives(List<Objective> objectives) {

+                Objective[] objectivesArray = objectives.toArray(new Objective[objectives.size()]);

+                Arrays.sort(objectivesArray, Comparator.comparingInt(Objective::getLevel));

+                return objectivesArray;

+        }

+

+        public Objective[][] getLeveledObjectives() {

+                return leveledObjectives;

+        }

+

+}

diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/Objective.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/Objective.java
new file mode 100644
index 00000000..b160b453
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/Objective.java
@@ -0,0 +1,110 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Miklos Foldenyi, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.store.query.dse.objectives;
+
+import tools.refinery.store.query.dse.DesignSpaceExplorationAdapter;
+
+import java.util.Comparator;
+
+/**
+ *
+ * Implementation of this interface represents a single objective of the DSE problem, which can assess a solution
+ * (trajectory) in a single number. It has a name and a comparator which orders two solution based on the calculated
+ * value.
+ * <p>
+ * Objectives can be either hard or soft objectives. Hard objectives can be satisfied or unsatisfied. If all of the hard
+ * objectives are satisfied on a single solution, then it is considered to be a valid (or goal) solution.
+ * <p>
+ * Certain objectives can have inner state for calculating the fitness value. In this case a new instance is necessary
+ * for every new thread, and the {@code createNew} method should not return the same instance more than once.
+ *
+ * @author Andras Szabolcs Nagy
+ *
+ */
+public interface Objective {
+
+        /**
+         * Returns the name of the objective.
+         *
+         * @return The name of the objective.
+         */
+        String getName();
+
+        /**
+         * Sets the {@link Comparator} which is used to compare fitness (doubles). It determines whether the objective is to
+         * minimize or maximize (or minimize or maximize a delta from a given number).
+         *
+         * @param comparator The comparator.
+         */
+        void setComparator(Comparator<Double> comparator);
+
+        /**
+         * Returns a {@link Comparator} which is used to compare fitness (doubles). It determines whether the objective is
+         * to minimize or maximize (or minimize or maximize a delta from a given number).
+         *
+         * @return The comparator.
+         */
+        Comparator<Double> getComparator();
+
+        /**
+         * Calculates the value of the objective on a given solution (trajectory).
+         *
+         * @param context
+         *            The {@link DesignSpaceExplorationAdapter}
+         * @return The objective value in double.
+         */
+        Double getFitness(DesignSpaceExplorationAdapter context);
+
+        /**
+         * Initializes the objective. It is called exactly once for every thread starts.
+         *
+         * @param context
+         *            The {@link DesignSpaceExplorationAdapter}.
+         */
+        void init(DesignSpaceExplorationAdapter context);
+
+        /**
+         * Returns an instance of the {@link Objective}. If it returns the same instance, all the methods has to be thread
+         * save as they are called concurrently.
+         *
+         * @return An instance of the objective.
+         */
+        Objective createNew();
+
+        /**
+         * Returns true if the objective is a hard objective. In such a case the method
+         * {@link Objective#satisfiesHardObjective(Double)} is called.
+         *
+         * @return True if the objective is a hard objective.
+         * @see Objective#satisfiesHardObjective(Double)
+         * @see Objective
+         */
+        boolean isHardObjective();
+
+        /**
+         * Determines if the given fitness value satisfies the hard objective.
+         *
+         * @param fitness
+         *            The fitness value of a solution.
+         * @return True if it satisfies the hard objective or it is a soft constraint.
+         * @see Objective
+         */
+        boolean satisfiesHardObjective(Double fitness);
+
+        /**
+         * Set the level of the objective.
+         */
+        void setLevel(int level);
+
+        /**
+         * Gets the level of the objective.
+         */
+        int getLevel();
+
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/ObjectiveComparatorHelper.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/ObjectiveComparatorHelper.java
new file mode 100644
index 00000000..23fb24ee
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/objectives/ObjectiveComparatorHelper.java
@@ -0,0 +1,218 @@
+/*******************************************************************************

+ * Copyright (c) 2010-2015, Andras Szabolcs Nagy, Abel Hegedus, Akos Horvath, Zoltan Ujhelyi and Daniel Varro

+ * This program and the accompanying materials are made available under the

+ * terms of the Eclipse Public License v. 2.0 which is available at

+ * http://www.eclipse.org/legal/epl-v20.html.

+ *

+ * SPDX-License-Identifier: EPL-2.0

+ *******************************************************************************/

+package tools.refinery.store.query.dse.objectives;

+

+import java.util.ArrayList;

+import java.util.Arrays;

+import java.util.HashMap;

+import java.util.List;

+import java.util.Map;

+import java.util.Random;

+

+import org.eclipse.viatra.query.runtime.matchers.util.Preconditions;

+

+/**

+ * This class is responsible to compare and sort fitness values. {@link TrajectoryFitness} instances can be added to an

+ * instance of this class, that it can sort them.

+ *

+ * @author András Szabolcs Nagy

+ */

+public class ObjectiveComparatorHelper {

+

+        private Objective[][] leveledObjectives;

+        private List<TrajectoryFitness> trajectoryFitnesses = new ArrayList<TrajectoryFitness>();

+        private Random random = new Random();

+        private boolean computeCrowdingDistance = false;

+

+        public ObjectiveComparatorHelper(Objective[][] leveledObjectives) {

+                this.leveledObjectives = leveledObjectives;

+        }

+

+        public void setComputeCrowdingDistance(boolean computeCrowdingDistance) {

+                this.computeCrowdingDistance = computeCrowdingDistance;

+        }

+

+        /**

+         * Compares two fitnesses based on hierarchical dominance. Returns -1 if the second parameter {@code o2} is a better

+         * solution ({@code o2} dominates {@code o1}), 1 if the first parameter {@code o1} is better ({@code o1} dominates

+         * {@code o2}) and returns 0 if they are non-dominating each other.

+         */

+        public int compare(Fitness o1, Fitness o2) {

+

+                levelsLoop:

+                for (Objective[] leveledObjective : leveledObjectives) {

+

+                        boolean o1HasBetterFitness = false;

+                        boolean o2HasBetterFitness = false;

+

+                        for (Objective objective : leveledObjective) {

+                                String objectiveName = objective.getName();

+                                int sgn = objective.getComparator().compare(o1.get(objectiveName), o2.get(objectiveName));

+

+                                if (sgn < 0) {

+                                        o2HasBetterFitness = true;

+                                }

+                                if (sgn > 0) {

+                                        o1HasBetterFitness = true;

+                                }

+                                if (o1HasBetterFitness && o2HasBetterFitness) {

+                                        continue levelsLoop;

+                                }

+                        }

+                        if (o2HasBetterFitness) {

+                                return -1;

+                        } else if (o1HasBetterFitness) {

+                                return 1;

+                        }

+                }

+

+                return 0;

+

+        }

+

+        /**

+         * Adds a {@link TrajectoryFitness} to an inner list to compare later.

+         *

+         * @param trajectoryFitness

+         */

+        public void addTrajectoryFitness(TrajectoryFitness trajectoryFitness) {

+                trajectoryFitnesses.add(trajectoryFitness);

+        }

+

+        /**

+         * Clears the inner {@link TrajectoryFitness} list.

+         */

+        public void clearTrajectoryFitnesses() {

+                trajectoryFitnesses.clear();

+        }

+

+        /**

+         * Returns the inner {@link TrajectoryFitness} list.

+         */

+        public List<TrajectoryFitness> getTrajectoryFitnesses() {

+                return trajectoryFitnesses;

+        }

+

+        /**

+         * Returns a random {@link TrajectoryFitness} from the pareto front.

+         */

+        public TrajectoryFitness getRandomBest() {

+                List<TrajectoryFitness> paretoFront = getParetoFront();

+                int randomIndex = random.nextInt(paretoFront.size());

+                return paretoFront.get(randomIndex);

+        }

+

+        /**

+         * Returns the pareto front of the previously added {@link TrajectoryFitness}.

+         */

+        public List<TrajectoryFitness> getParetoFront() {

+                return getFronts().get(0);

+        }

+

+        /**

+         * Returns the previously added {@link TrajectoryFitness} instances in fronts.

+         */

+        public List<? extends List<TrajectoryFitness>> getFronts() {

+                Preconditions.checkArgument(!trajectoryFitnesses.isEmpty(), "No trajectory fitnesses were added.");

+                List<ArrayList<TrajectoryFitness>> fronts = new ArrayList<ArrayList<TrajectoryFitness>>();

+

+                Map<TrajectoryFitness, ArrayList<TrajectoryFitness>> dominatedInstances = new HashMap<TrajectoryFitness, ArrayList<TrajectoryFitness>>();

+                Map<TrajectoryFitness, Integer> dominatingInstances = new HashMap<TrajectoryFitness, Integer>();

+

+                // calculate dominations

+                for (TrajectoryFitness TrajectoryFitnessP : trajectoryFitnesses) {

+                        dominatedInstances.put(TrajectoryFitnessP, new ArrayList<TrajectoryFitness>());

+                        dominatingInstances.put(TrajectoryFitnessP, 0);

+

+                        for (TrajectoryFitness TrajectoryFitnessQ : trajectoryFitnesses) {

+                                int dominates = compare(TrajectoryFitnessP.fitness, TrajectoryFitnessQ.fitness);

+                                if (dominates > 0) {

+                                        dominatedInstances.get(TrajectoryFitnessP).add(TrajectoryFitnessQ);

+                                } else if (dominates < 0) {

+                                        dominatingInstances.put(TrajectoryFitnessP, dominatingInstances.get(TrajectoryFitnessP) + 1);

+                                }

+                        }

+

+                        if (dominatingInstances.get(TrajectoryFitnessP) == 0) {

+                                // p belongs to the first front

+                                TrajectoryFitnessP.rank = 1;

+                                if (fronts.isEmpty()) {

+                                        ArrayList<TrajectoryFitness> firstDominationFront = new ArrayList<TrajectoryFitness>();

+                                        firstDominationFront.add(TrajectoryFitnessP);

+                                        fronts.add(firstDominationFront);

+                                } else {

+                                        List<TrajectoryFitness> firstDominationFront = fronts.get(0);

+                                        firstDominationFront.add(TrajectoryFitnessP);

+                                }

+                        }

+                }

+

+                // create fronts

+                int i = 1;

+                while (fronts.size() == i) {

+                        ArrayList<TrajectoryFitness> nextDominationFront = new ArrayList<TrajectoryFitness>();

+                        for (TrajectoryFitness TrajectoryFitnessP : fronts.get(i - 1)) {

+                                for (TrajectoryFitness TrajectoryFitnessQ : dominatedInstances.get(TrajectoryFitnessP)) {

+                                        dominatingInstances.put(TrajectoryFitnessQ, dominatingInstances.get(TrajectoryFitnessQ) - 1);

+                                        if (dominatingInstances.get(TrajectoryFitnessQ) == 0) {

+                                                TrajectoryFitnessQ.rank = i + 1;

+                                                nextDominationFront.add(TrajectoryFitnessQ);

+                                        }

+                                }

+                        }

+                        i++;

+                        if (!nextDominationFront.isEmpty()) {

+                                if (computeCrowdingDistance) {

+                                        crowdingDistanceAssignment(nextDominationFront, leveledObjectives);

+                                }

+                                fronts.add(nextDominationFront);

+                        }

+                }

+

+                return fronts;

+        }

+

+        /**

+         * Executes the crowding distance assignment for the specified front.

+         *

+         * @param front

+         */

+        public static void crowdingDistanceAssignment(List<TrajectoryFitness> front, Objective[][] leveledObjectives) {

+

+                for (TrajectoryFitness InstanceData : front) {

+                        // initialize crowding distance

+                        InstanceData.crowdingDistance = 0;

+                }

+

+                for (final Objective[] objectives : leveledObjectives) {

+                        for (final Objective objective : objectives) {

+

+                                final String m = objective.getName();

+                                TrajectoryFitness[] sortedFront = front.toArray(new TrajectoryFitness[0]);

+                                // sort using m-th objective value

+                                Arrays.sort(sortedFront, (o1, o2) -> objective.getComparator().compare(o1.fitness.get(m), o2.fitness.get(m)));

+                                // so that boundary points are always selected

+                                sortedFront[0].crowdingDistance = Double.POSITIVE_INFINITY;

+                                sortedFront[sortedFront.length - 1].crowdingDistance = Double.POSITIVE_INFINITY;

+                                // If minimal and maximal fitness value for this objective are

+                                // equal, then do not change crowding distance

+                                if (sortedFront[0].fitness.get(m) != sortedFront[sortedFront.length - 1].fitness.get(m)) {

+                                        for (int i = 1; i < sortedFront.length - 1; i++) {

+                                                double newCrowdingDistance = sortedFront[i].crowdingDistance;

+                                                newCrowdingDistance += (sortedFront[i + 1].fitness.get(m) - sortedFront[i - 1].fitness.get(m))

+                                                                / (sortedFront[sortedFront.length - 1].fitness.get(m) - sortedFront[0].fitness.get(m));

+

+                                                sortedFront[i].crowdingDistance = newCrowdingDistance;

+                                        }

+                                }

+                        }

+                }

+        }

+

+}

diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/strategy/DepthFirstStrategy.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/strategy/DepthFirstStrategy.java
new file mode 100644
index 00000000..8192048a
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/dse/strategy/DepthFirstStrategy.java
@@ -0,0 +1,108 @@
+package tools.refinery.store.query.dse.strategy;
+
+import tools.refinery.store.query.dse.DesignSpaceExplorationAdapter;
+import tools.refinery.store.query.dse.Strategy;
+import tools.refinery.store.query.dse.internal.Activation;
+import tools.refinery.store.query.dse.objectives.Fitness;
+
+import java.util.Collection;
+
+public class DepthFirstStrategy implements Strategy {
+
+        private DesignSpaceExplorationAdapter dseAdapter;
+
+        private int maxDepth;
+        private boolean backTrackIfSolution = true;
+
+        public DepthFirstStrategy() {
+                this(-1);
+        }
+
+        public DepthFirstStrategy(int maxDepth) {
+                if (maxDepth < 0) {
+                        this.maxDepth = Integer.MAX_VALUE;
+                } else {
+                        this.maxDepth = maxDepth;
+                }
+        }
+
+        public DepthFirstStrategy continueIfHardObjectivesFulfilled() {
+                backTrackIfSolution = false;
+                return this;
+        }
+
+        @Override
+        public void initStrategy(DesignSpaceExplorationAdapter designSpaceExplorationAdapter) {
+                this.dseAdapter = designSpaceExplorationAdapter;
+        }
+
+        @Override
+        public void explore() {
+                mainloop: while (true) {
+                        var globalConstraintsAreSatisfied = dseAdapter.checkGlobalConstraints();
+                        if (!globalConstraintsAreSatisfied) {
+                                var isSuccessfulUndo = dseAdapter.backtrack();
+                                if (!isSuccessfulUndo) {
+//                                      "Global constraint is not satisfied and cannot backtrack."
+                                        break;
+                                }
+                                else {
+//                                      "Global constraint is not satisfied, backtrack."
+                                        continue;
+                                }
+                        }
+
+                        Fitness fitness = dseAdapter.calculateFitness();
+                        if (fitness.isSatisfiesHardObjectives()) {
+                                dseAdapter.newSolution();
+                                if (backTrackIfSolution) {
+                                        var isSuccessfulUndo = dseAdapter.backtrack();
+                                        if (!isSuccessfulUndo) {
+//                                      "Found a solution but cannot backtrack."
+                                                break;
+                                        } else {
+//                                      "Found a solution, backtrack."
+                                                continue;
+                                        }
+                                }
+                        }
+
+                        var depth = dseAdapter.getDepth();
+                        if (dseAdapter.getDepth() >= maxDepth) {
+                                var isSuccessfulUndo = dseAdapter.backtrack();
+                                if (!isSuccessfulUndo) {
+//                                      "Reached max depth but cannot backtrack."
+                                        break;
+                                }
+                        }
+
+                        Collection<Activation> activations;
+                        do {
+                                activations = dseAdapter.getUntraversedActivations();
+                                if (activations.isEmpty()) {
+                                        if (!dseAdapter.backtrack()) {
+        //                                      "No more transitions from current state and cannot backtrack."
+                                                break mainloop;
+                                        }
+                                        else {
+        //                                      "No more transitions from current state, backtrack."
+                                                continue;
+                                        }
+                                }
+                        } while (activations.isEmpty());
+
+                        dseAdapter.fireRandomActivation();
+//                      if (dseAdapter.isCurrentInTrajectory()) {
+//                              if (!dseAdapter.backtrack()) {
+////                                    TODO: throw exception
+////                                    "The new state is present in the trajectory but cannot backtrack. Should never happen!"
+//                                      break;
+//                              }
+//                              else {
+////                                    "The new state is already visited in the trajectory, backtrack."
+//                                      continue;
+//                              }
+//                      }
+                }
+        }
+}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/dse/DesignSpaceExplorationTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/dse/DesignSpaceExplorationTest.java
new file mode 100644
index 00000000..06e2e076
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/dse/DesignSpaceExplorationTest.java
@@ -0,0 +1,117 @@
+package tools.refinery.store.query.dse;
+
+import guru.nidi.graphviz.engine.Format;
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.dse.internal.TransformationRule;
+import tools.refinery.store.query.dse.strategy.BestFirstStrategy;
+import tools.refinery.store.query.dse.strategy.DepthFirstStrategy;
+import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
+import tools.refinery.store.query.view.AnySymbolView;
+import tools.refinery.store.query.view.KeyOnlyView;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.visualization.ModelVisualizerAdapter;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static tools.refinery.store.query.literal.Literals.not;
+import static tools.refinery.store.query.viatra.tests.QueryAssertions.assertResults;
+
+public class DesignSpaceExplorationTest {
+//      private static final Symbol<Boolean> namedElement = Symbol.of("NamedElement", 1);
+//      private static final Symbol<Boolean> attribute = Symbol.of("Attribute", 1);
+//      private static final Symbol<Boolean> method = Symbol.of("Method", 1);
+//      private static final Symbol<Boolean> dataDependency = Symbol.of("DataDependency", 2);
+//      private static final Symbol<Boolean> functionalDependency = Symbol.of("FunctionalDependency", 2);
+
+        private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
+        private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1);
+        private static final Symbol<Boolean> feature = Symbol.of("Feature", 1);
+
+        private static final Symbol<Boolean> isEncapsulatedBy = Symbol.of("IsEncapsulatedBy", 2);
+        private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2);
+
+        private static final Symbol<Boolean> features = Symbol.of("Features", 2);
+        private static final Symbol<Boolean> classes = Symbol.of("Classes", 2);
+
+        private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel);
+        private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement);
+        private static final AnySymbolView featureView = new KeyOnlyView<>(feature);
+        private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
+        private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
+        private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
+        private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
+
+        @Test
+        void createObjectTest() {
+                var store = ModelStore.builder()
+                                .with(ViatraModelQueryAdapter.builder())
+                                .with(DesignSpaceExplorationAdapter.builder())
+                                .build();
+
+                var model = store.createEmptyModel();
+                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+
+                assertEquals(0, dseAdapter.getModelSize());
+
+                var newModel = dseAdapter.createObject();
+                var newModelId = newModel.get(0);
+                var newClass1 = dseAdapter.createObject();
+                var newClass1Id = newClass1.get(0);
+                var newClass2 = dseAdapter.createObject();
+                var newClass2Id = newClass2.get(0);
+                var newField = dseAdapter.createObject();
+                var newFieldId = newField.get(0);
+
+                assertEquals(0, newModelId);
+                assertEquals(1, newClass1Id);
+                assertEquals(2, newClass2Id);
+                assertEquals(3, newFieldId);
+                assertEquals(4, dseAdapter.getModelSize());
+        }
+
+        @Test
+        void deleteMiddleObjectTest() {
+                var store = ModelStore.builder()
+                                .with(ViatraModelQueryAdapter.builder())
+                                .with(DesignSpaceExplorationAdapter.builder())
+                                .build();
+
+                var model = store.createEmptyModel();
+                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+
+                assertEquals(0, dseAdapter.getModelSize());
+
+                var newObject0 = dseAdapter.createObject();
+                var newObject0Id = newObject0.get(0);
+                var newObject1 = dseAdapter.createObject();
+                var newObject1Id = newObject1.get(0);
+                var newObject2 = dseAdapter.createObject();
+                var newObject2Id = newObject2.get(0);
+                var newObject3 = dseAdapter.createObject();
+                var newObject3Id = newObject3.get(0);
+
+                assertEquals(0, newObject0Id);
+                assertEquals(1, newObject1Id);
+                assertEquals(2, newObject2Id);
+                assertEquals(3, newObject3Id);
+                assertEquals(4, dseAdapter.getModelSize());
+
+                dseAdapter.deleteObject(newObject1);
+                assertEquals(4, dseAdapter.getModelSize());
+
+                var newObject4 = dseAdapter.createObject();
+                var newObject4Id = newObject4.get(0);
+                assertEquals(4, newObject4Id);
+                assertEquals(5, dseAdapter.getModelSize());
+
+                dseAdapter.deleteObject(newObject4);
+                assertEquals(5, dseAdapter.getModelSize());
+        }
+
+}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/dse/TransformationRuleTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/dse/TransformationRuleTest.java
new file mode 100644
index 00000000..1fb3421b
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/dse/TransformationRuleTest.java
@@ -0,0 +1,403 @@
+package tools.refinery.store.query.dse;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.dse.internal.TransformationRule;
+import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
+import tools.refinery.store.query.view.AnySymbolView;
+import tools.refinery.store.query.view.KeyOnlyView;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static tools.refinery.store.query.literal.Literals.not;
+import static tools.refinery.store.query.viatra.tests.QueryAssertions.assertResults;
+
+public class TransformationRuleTest {
+
+        private static final Symbol<Boolean> classModel = Symbol.of("ClassModel", 1);
+        private static final Symbol<Boolean> classElement = Symbol.of("ClassElement", 1);
+        private static final Symbol<Boolean> feature = Symbol.of("Feature", 1);
+
+        private static final Symbol<Boolean> isEncapsulatedBy = Symbol.of("IsEncapsulatedBy", 2);
+        private static final Symbol<Boolean> encapsulates = Symbol.of("Encapsulates", 2);
+
+        private static final Symbol<Boolean> features = Symbol.of("Features", 2);
+        private static final Symbol<Boolean> classes = Symbol.of("Classes", 2);
+
+        private static final AnySymbolView classModelView = new KeyOnlyView<>(classModel);
+        private static final AnySymbolView classElementView = new KeyOnlyView<>(classElement);
+        private static final AnySymbolView featureView = new KeyOnlyView<>(feature);
+        private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
+        private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
+        private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
+        private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
+
+        @Test
+        void activationsTest() {
+                var assignFeaturePreconditionHelper = Query.of("AssignFeaturePreconditionHelper",
+                                (builder, model, c, f) -> builder.clause(
+                                                classElementView.call(c),
+                                                classesView.call(model, c),
+                                                encapsulatesView.call(c, f)
+                                ));
+
+                var assignFeaturePrecondition = Query.of("AssignFeaturePrecondition", (builder, c2, f)
+                                -> builder.clause((model, c1) -> List.of(
+                                classModelView.call(model),
+                                featureView.call(f),
+                                classElementView.call(c2),
+                                featuresView.call(model, f),
+                                classesView.call(model, c1),
+                                not(assignFeaturePreconditionHelper.call(model, c2, f)),
+                                not(encapsulatesView.call(c2, f))
+                )));
+
+                var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
+                                (builder, model, c) -> builder.clause((f) -> List.of(
+                                                classModelView.call(model),
+                                                classElementView.call(c),
+                                                featuresView.call(model, f),
+                                                not(encapsulatesView.call(c, f))
+                                )));
+
+                TransformationRule assignFeatureRule = new TransformationRule("AssignFeature",
+                                assignFeaturePrecondition,
+                                (model) -> {
+                                        var isEncapsulatedByInterpretation = model.getInterpretation(isEncapsulatedBy);
+                                        return ((Tuple activation) -> {
+                                                var feature = activation.get(0);
+                                                var classElement = activation.get(1);
+
+                                                isEncapsulatedByInterpretation.put(Tuple.of(feature, classElement), true);
+                                        });
+                                });
+
+                TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass",
+                                deleteEmptyClassPrecondition,
+                                (model) -> {
+                                        var classesInterpretation = model.getInterpretation(classes);
+                                        var classElementInterpretation = model.getInterpretation(classElement);
+                                        return ((Tuple activation) -> {
+                                                var modelElement = activation.get(0);
+                                                var classElement = activation.get(1);
+
+                                                classesInterpretation.put(Tuple.of(modelElement, classElement), false);
+                                                classElementInterpretation.put(Tuple.of(classElement), false);
+                                        });
+                                });
+
+
+                var store = ModelStore.builder()
+                                .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
+                                .with(ViatraModelQueryAdapter.builder()
+                                                .queries(assignFeaturePrecondition, assignFeaturePreconditionHelper,
+                                                                deleteEmptyClassPrecondition))
+                                .with(DesignSpaceExplorationAdapter.builder())
+                                .build();
+
+                var model = store.createEmptyModel();
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+                assignFeatureRule.prepare(model, queryEngine);
+                deleteEmptyClassRule.prepare(model, queryEngine);
+
+                var classModelInterpretation = model.getInterpretation(classModel);
+                var classElementInterpretation = model.getInterpretation(classElement);
+                var featureInterpretation = model.getInterpretation(feature);
+                var featuresInterpretation = model.getInterpretation(features);
+                var classesInterpretation = model.getInterpretation(classes);
+
+                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                var newModel = dseAdapter.createObject();
+                var newModelId = newModel.get(0);
+                var newClass1 = dseAdapter.createObject();
+                var newClass1Id = newClass1.get(0);
+                var newClass2 = dseAdapter.createObject();
+                var newClass2Id = newClass2.get(0);
+                var newField = dseAdapter.createObject();
+                var newFieldId = newField.get(0);
+
+                classModelInterpretation.put(newModel, true);
+                classElementInterpretation.put(newClass1, true);
+                classElementInterpretation.put(newClass2, true);
+                featureInterpretation.put(newField, true);
+                classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
+                classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
+                featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
+
+                queryEngine.flushChanges();
+
+                var assignFeatureRuleActivations = assignFeatureRule.getAllActivationsAsSets();
+                var deleteEmptyClassRuleActivations = deleteEmptyClassRule.getAllActivationsAsSets();
+
+                assertResults(Map.of(
+                                Tuple.of(newClass1Id, newFieldId), true,
+                                Tuple.of(newClass2Id, newFieldId), true
+                ), assignFeatureRuleActivations);
+
+                assertResults(Map.of(
+                                Tuple.of(newModelId, newClass1Id), true,
+                                Tuple.of(newModelId, newClass2Id), true
+                ), deleteEmptyClassRuleActivations);
+        }
+
+        @Test
+        void randomActivationTest() {
+                var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
+                                (builder, model, c) -> builder.clause((f) -> List.of(
+                                                classModelView.call(model),
+                                                classElementView.call(c),
+                                                featuresView.call(model, f),
+                                                not(encapsulatesView.call(c, f))
+                                )));
+
+                TransformationRule deleteEmptyClassRule0 = new TransformationRule("DeleteEmptyClass0",
+                                deleteEmptyClassPrecondition,
+                                (model) -> {
+                                        var classesInterpretation = model.getInterpretation(classes);
+                                        var classElementInterpretation = model.getInterpretation(classElement);
+                                        return ((Tuple activation) -> {
+                                                var modelElement = activation.get(0);
+                                                var classElement = activation.get(1);
+
+                                                classesInterpretation.put(Tuple.of(modelElement, classElement), false);
+                                                classElementInterpretation.put(Tuple.of(classElement), false);
+                                        });
+                                },
+                                0L);
+
+                TransformationRule deleteEmptyClassRule1 = new TransformationRule("DeleteEmptyClass1",
+                                deleteEmptyClassPrecondition,
+                                (model) -> {
+                                        var classesInterpretation = model.getInterpretation(classes);
+                                        var classElementInterpretation = model.getInterpretation(classElement);
+                                        return ((Tuple activation) -> {
+                                                var modelElement = activation.get(0);
+                                                var classElement = activation.get(1);
+
+                                                classesInterpretation.put(Tuple.of(modelElement, classElement), false);
+                                                classElementInterpretation.put(Tuple.of(classElement), false);
+                                        });
+                                },
+                                78634L);
+
+                var store = ModelStore.builder()
+                                .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
+                                .with(ViatraModelQueryAdapter.builder()
+                                                .queries(deleteEmptyClassPrecondition))
+                                .with(DesignSpaceExplorationAdapter.builder())
+                                .build();
+
+                var model = store.createEmptyModel();
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+                deleteEmptyClassRule0.prepare(model, queryEngine);
+                deleteEmptyClassRule1.prepare(model, queryEngine);
+
+                var classModelInterpretation = model.getInterpretation(classModel);
+                var classElementInterpretation = model.getInterpretation(classElement);
+                var featureInterpretation = model.getInterpretation(feature);
+                var featuresInterpretation = model.getInterpretation(features);
+                var classesInterpretation = model.getInterpretation(classes);
+
+                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                var newModel = dseAdapter.createObject();
+                var newModelId = newModel.get(0);
+                var newClass1 = dseAdapter.createObject();
+                var newClass1Id = newClass1.get(0);
+                var newClass2 = dseAdapter.createObject();
+                var newClass2Id = newClass2.get(0);
+                var newField = dseAdapter.createObject();
+                var newFieldId = newField.get(0);
+
+                classModelInterpretation.put(newModel, true);
+                classElementInterpretation.put(newClass1, true);
+                classElementInterpretation.put(newClass2, true);
+                featureInterpretation.put(newField, true);
+                classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
+                classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
+                featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
+
+                queryEngine.flushChanges();
+
+
+                var activation0 = deleteEmptyClassRule0.getRandomActivation().activation();
+                var activation1 = deleteEmptyClassRule1.getRandomActivation().activation();
+
+                assertResults(Map.of(
+                                Tuple.of(newModelId, newClass1Id), true,
+                                Tuple.of(newModelId, newClass2Id), true
+                ), deleteEmptyClassRule0.getAllActivationsAsSets());
+
+                assertResults(Map.of(
+                                Tuple.of(newModelId, newClass1Id), true,
+                                Tuple.of(newModelId, newClass2Id), true
+                ), deleteEmptyClassRule1.getAllActivationsAsSets());
+
+                assertEquals(Tuple.of(newModelId, newClass2Id), activation0);
+                assertEquals(Tuple.of(newModelId, newClass1Id), activation1);
+
+        }
+
+        @Test
+        void fireTest() {
+                var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
+                                (builder, model, c) -> builder.clause((f) -> List.of(
+                                                classModelView.call(model),
+                                                classElementView.call(c),
+                                                featuresView.call(model, f),
+                                                not(encapsulatesView.call(c, f))
+                                )));
+
+                TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass",
+                                deleteEmptyClassPrecondition,
+                                (model) -> {
+                                        var classesInterpretation = model.getInterpretation(classes);
+                                        var classElementInterpretation = model.getInterpretation(classElement);
+                                        return ((Tuple activation) -> {
+                                                var modelElement = activation.get(0);
+                                                var classElement = activation.get(1);
+
+                                                classesInterpretation.put(Tuple.of(modelElement, classElement), false);
+                                                classElementInterpretation.put(Tuple.of(classElement), false);
+                                        });
+                                });
+
+                var store = ModelStore.builder()
+                                .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
+                                .with(ViatraModelQueryAdapter.builder()
+                                                .queries(deleteEmptyClassPrecondition))
+                                .with(DesignSpaceExplorationAdapter.builder())
+                                .build();
+
+                var model = store.createEmptyModel();
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+                deleteEmptyClassRule.prepare(model, queryEngine);
+
+                var classModelInterpretation = model.getInterpretation(classModel);
+                var classElementInterpretation = model.getInterpretation(classElement);
+                var featureInterpretation = model.getInterpretation(feature);
+                var featuresInterpretation = model.getInterpretation(features);
+                var classesInterpretation = model.getInterpretation(classes);
+
+                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                var newModel = dseAdapter.createObject();
+                var newModelId = newModel.get(0);
+                var newClass1 = dseAdapter.createObject();
+                var newClass1Id = newClass1.get(0);
+                var newClass2 = dseAdapter.createObject();
+                var newClass2Id = newClass2.get(0);
+                var newField = dseAdapter.createObject();
+                var newFieldId = newField.get(0);
+
+                classModelInterpretation.put(newModel, true);
+                classElementInterpretation.put(newClass1, true);
+                classElementInterpretation.put(newClass2, true);
+                featureInterpretation.put(newField, true);
+                classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
+                classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
+                featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
+
+                queryEngine.flushChanges();
+
+                assertResults(Map.of(
+                                Tuple.of(newModelId, newClass1Id), true,
+                                Tuple.of(newModelId, newClass2Id), true
+                ), deleteEmptyClassRule.getAllActivationsAsSets());
+
+
+                deleteEmptyClassRule.fireActivation(Tuple.of(0, 1));
+
+                assertResults(Map.of(
+                                Tuple.of(newModelId, newClass1Id), false,
+                                Tuple.of(newModelId, newClass2Id), true
+                ), deleteEmptyClassRule.getAllActivationsAsSets());
+        }
+
+        @Test
+        void randomFireTest() {
+                var deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
+                                (builder, model, c) -> builder.clause((f) -> List.of(
+                                                classModelView.call(model),
+                                                classElementView.call(c),
+                                                featuresView.call(model, f),
+                                                not(encapsulatesView.call(c, f))
+                                )));
+
+                TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass0",
+                                deleteEmptyClassPrecondition,
+                                (model) -> {
+                                        var classesInterpretation = model.getInterpretation(classes);
+                                        var classElementInterpretation = model.getInterpretation(classElement);
+                                        return ((Tuple activation) -> {
+                                                var modelElement = activation.get(0);
+                                                var classElement = activation.get(1);
+
+                                                classesInterpretation.put(Tuple.of(modelElement, classElement), false);
+                                                classElementInterpretation.put(Tuple.of(classElement), false);
+                                        });
+                                },
+                                0L);
+
+                var store = ModelStore.builder()
+                                .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
+                                .with(ViatraModelQueryAdapter.builder()
+                                                .queries(deleteEmptyClassPrecondition))
+                                .with(DesignSpaceExplorationAdapter.builder())
+                                .build();
+
+                var model = store.createEmptyModel();
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+                deleteEmptyClassRule.prepare(model, queryEngine);
+
+                var classModelInterpretation = model.getInterpretation(classModel);
+                var classElementInterpretation = model.getInterpretation(classElement);
+                var featureInterpretation = model.getInterpretation(feature);
+                var featuresInterpretation = model.getInterpretation(features);
+                var classesInterpretation = model.getInterpretation(classes);
+
+                var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                var newModel = dseAdapter.createObject();
+                var newModelId = newModel.get(0);
+                var newClass1 = dseAdapter.createObject();
+                var newClass1Id = newClass1.get(0);
+                var newClass2 = dseAdapter.createObject();
+                var newClass2Id = newClass2.get(0);
+                var newField = dseAdapter.createObject();
+                var newFieldId = newField.get(0);
+
+                classModelInterpretation.put(newModel, true);
+                classElementInterpretation.put(newClass1, true);
+                classElementInterpretation.put(newClass2, true);
+                featureInterpretation.put(newField, true);
+                classesInterpretation.put(Tuple.of(newModelId, newClass1Id), true);
+                classesInterpretation.put(Tuple.of(newModelId, newClass2Id), true);
+                featuresInterpretation.put(Tuple.of(newModelId, newFieldId), true);
+
+                queryEngine.flushChanges();
+
+                assertResults(Map.of(
+                                Tuple.of(newModelId, newClass1Id), true,
+                                Tuple.of(newModelId, newClass2Id), true
+                ), deleteEmptyClassRule.getAllActivationsAsSets());
+
+                deleteEmptyClassRule.fireRandomActivation();
+
+                assertResults(Map.of(
+                                Tuple.of(newModelId, newClass1Id), true,
+                                Tuple.of(newModelId, newClass2Id), false
+                ), deleteEmptyClassRule.getAllActivationsAsSets());
+
+                deleteEmptyClassRule.fireRandomActivation();
+
+                assertResults(Map.of(
+                                Tuple.of(newModelId, newClass1Id), false,
+                                Tuple.of(newModelId, newClass2Id), false
+                ), deleteEmptyClassRule.getAllActivationsAsSets());
+
+        }
+}
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 aafbe130..24d4088a 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
@@ -59,13 +59,13 @@ public class ModelStoreBuilderImpl implements ModelStoreBuilder {
 
         @Override
         public ModelStore build() {
+                for (int i = adapters.size() - 1; i >= 0; i--) {
+                        adapters.get(i).configure(this);
+                }
                 var stores = new HashMap<AnySymbol, VersionedMapStore<Tuple, ?>>(allSymbols.size());
                 for (var entry : equivalenceClasses.entrySet()) {
                         createStores(stores, entry.getKey(), entry.getValue());
                 }
-                for (int i = adapters.size() - 1; i >= 0; i--) {
-                        adapters.get(i).configure(this);
-                }
                 var modelStore = new ModelStoreImpl(stores, adapters.size());
                 for (var adapterBuilder : adapters) {
                         var storeAdapter = adapterBuilder.build(modelStore);