55 files changed, 1439 insertions, 1407 deletions

diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/ActionFactory.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/ActionFactory.java
deleted file mode 100644
index 524c2f55..00000000
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/ActionFactory.java
+++ /dev/null
@@ -1,14 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.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-dse/src/main/java/tools/refinery/store/dse/modification/DanglingEdges.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/DanglingEdges.java
new file mode 100644
index 00000000..ac9d125b
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/DanglingEdges.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.modification;
+
+public enum DanglingEdges {
+        IGNORE,
+        DELETE,
+        FAIL
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/ModificationAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/ModificationAdapter.java
index f15c16e0..58b60499 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/ModificationAdapter.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/ModificationAdapter.java
@@ -16,7 +16,7 @@ public interface ModificationAdapter extends ModelAdapter {
 
         Tuple1 createObject();
 
-        Tuple deleteObject(Tuple tuple);
+        boolean deleteObject(Tuple tuple, DanglingEdges danglingEdges);
 
         static ModificationBuilder builder() {
                 return new ModificationBuilderImpl();
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/actions/CreateActionLiteral.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/actions/CreateActionLiteral.java
new file mode 100644
index 00000000..5b86a5e1
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/actions/CreateActionLiteral.java
@@ -0,0 +1,43 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.modification.actions;
+
+import tools.refinery.store.dse.modification.ModificationAdapter;
+import tools.refinery.store.dse.transition.actions.AbstractActionLiteral;
+import tools.refinery.store.dse.transition.actions.BoundActionLiteral;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.List;
+
+public class CreateActionLiteral extends AbstractActionLiteral {
+        private final NodeVariable variable;
+
+        public CreateActionLiteral(NodeVariable variable) {
+
+                this.variable = variable;
+        }
+
+        public NodeVariable getVariable() {
+                return variable;
+        }
+
+        @Override
+        public List<NodeVariable> getInputVariables() {
+                return List.of();
+        }
+
+        @Override
+        public List<NodeVariable> getOutputVariables() {
+                return List.of(variable);
+        }
+
+        @Override
+        public BoundActionLiteral bindToModel(Model model) {
+                var adapter = model.getAdapter(ModificationAdapter.class);
+                return ignoredTuple -> adapter.createObject();
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/actions/DeleteActionLiteral.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/actions/DeleteActionLiteral.java
new file mode 100644
index 00000000..18ad2b9d
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/actions/DeleteActionLiteral.java
@@ -0,0 +1,51 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.modification.actions;
+
+import tools.refinery.store.dse.modification.DanglingEdges;
+import tools.refinery.store.dse.modification.ModificationAdapter;
+import tools.refinery.store.dse.transition.actions.AbstractActionLiteral;
+import tools.refinery.store.dse.transition.actions.BoundActionLiteral;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.List;
+
+public class DeleteActionLiteral extends AbstractActionLiteral {
+        private final NodeVariable variable;
+        private final DanglingEdges danglingEdges;
+
+        public DeleteActionLiteral(NodeVariable variable, DanglingEdges danglingEdges) {
+
+                this.variable = variable;
+                this.danglingEdges = danglingEdges;
+        }
+
+        public NodeVariable getVariable() {
+                return variable;
+        }
+
+        public DanglingEdges getDanglingEdges() {
+                return danglingEdges;
+        }
+
+        @Override
+        public List<NodeVariable> getInputVariables() {
+                return List.of(variable);
+        }
+
+        @Override
+        public List<NodeVariable> getOutputVariables() {
+                return List.of();
+        }
+
+        @Override
+        public BoundActionLiteral bindToModel(Model model) {
+                var adapter = model.getAdapter(ModificationAdapter.class);
+                return tuple -> adapter.deleteObject(tuple, danglingEdges) ? Tuple.of() : null;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/actions/ModificationActionLiterals.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/actions/ModificationActionLiterals.java
new file mode 100644
index 00000000..31f50ac7
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/actions/ModificationActionLiterals.java
@@ -0,0 +1,23 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.modification.actions;
+
+import tools.refinery.store.dse.modification.DanglingEdges;
+import tools.refinery.store.query.term.NodeVariable;
+
+public class ModificationActionLiterals {
+        private ModificationActionLiterals() {
+                throw new IllegalArgumentException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static CreateActionLiteral create(NodeVariable variable) {
+                return new CreateActionLiteral(variable);
+        }
+
+        public static DeleteActionLiteral delete(NodeVariable variable, DanglingEdges danglingEdges) {
+                return new DeleteActionLiteral(variable, danglingEdges);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/internal/ModificationAdapterImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/internal/ModificationAdapterImpl.java
index b2a80d71..4e77c462 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/internal/ModificationAdapterImpl.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/modification/internal/ModificationAdapterImpl.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.dse.modification.internal;
 
 import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.store.dse.modification.DanglingEdges;
 import tools.refinery.store.dse.modification.ModificationAdapter;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.model.Model;
@@ -13,6 +14,8 @@ import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.tuple.Tuple1;
 
+import java.util.HashSet;
+
 public class ModificationAdapterImpl implements ModificationAdapter {
         static final Symbol<Integer> NEXT_ID = Symbol.of("NEXT_ID", 0, Integer.class, 0);
 
@@ -49,14 +52,56 @@ public class ModificationAdapterImpl implements ModificationAdapter {
         }
 
         @Override
-        public Tuple deleteObject(Tuple tuple) {
+        public boolean deleteObject(Tuple tuple, DanglingEdges danglingEdges) {
                 if (tuple.getSize() != 1) {
                         throw new IllegalArgumentException("Tuple size must be 1");
                 }
-//              TODO: implement more efficient deletion
-                if (tuple.get(0) == getModelSize() - 1) {
-                        nodeCountInterpretation.put(Tuple.of(), getModelSize() - 1);
+                int objectId = tuple.get(0);
+                if (danglingEdges == DanglingEdges.DELETE) {
+                        deleteDanglingEdges(objectId);
+                } else if (danglingEdges == DanglingEdges.FAIL && hasDanglingEdges(objectId)) {
+                        return false;
+
+                }
+                int modelSize = getModelSize();
+                if (objectId == modelSize - 1) {
+                        nodeCountInterpretation.put(Tuple.of(), modelSize - 1);
+                }
+                return true;
+        }
+
+        private void deleteDanglingEdges(int objectId) {
+                for (var symbol : model.getStore().getSymbols()) {
+                        deleteDanglingEdges(objectId, (Symbol<?>) symbol);
+                }
+        }
+
+        private <T> void deleteDanglingEdges(int objectId, Symbol<T> symbol) {
+                var interpretation = model.getInterpretation(symbol);
+                var toDelete = new HashSet<Tuple>();
+                int arity = symbol.arity();
+                for (int i = 0; i < arity; i++) {
+                        var cursor = interpretation.getAdjacent(i, objectId);
+                        while (cursor.move()) {
+                                toDelete.add(cursor.getKey());
+                        }
+                }
+                var defaultValue = symbol.defaultValue();
+                for (var tuple : toDelete) {
+                        interpretation.put(tuple, defaultValue);
+                }
+        }
+
+        private boolean hasDanglingEdges(int objectId) {
+                for (var symbol : model.getStore().getSymbols()) {
+                        var interpretation = model.getInterpretation(symbol);
+                        int arity = symbol.arity();
+                        for (int i = 0; i < arity; i++) {
+                                if (interpretation.getAdjacentSize(i, objectId) > 0) {
+                                        return true;
+                                }
+                        }
                 }
-                return tuple;
+                return false;
         }
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStoreManager.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStoreManager.java
index 0b9aae9c..4ccba6f7 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStoreManager.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/strategy/BestFirstStoreManager.java
@@ -5,7 +5,6 @@
  */
 package tools.refinery.store.dse.strategy;
 
-import org.eclipse.collections.api.block.procedure.Procedure;
 import tools.refinery.store.dse.transition.DesignSpaceExplorationStoreAdapter;
 import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
 import tools.refinery.store.dse.transition.statespace.ActivationStore;
@@ -24,6 +23,8 @@ import tools.refinery.visualization.ModelVisualizerStoreAdapter;
 import tools.refinery.visualization.statespace.VisualizationStore;
 import tools.refinery.visualization.statespace.internal.VisualizationStoreImpl;
 
+import java.util.function.Consumer;
+
 public class BestFirstStoreManager {
 
         ModelStore modelStore;
@@ -39,7 +40,7 @@ public class BestFirstStoreManager {
                                 modelStore.getAdapter(DesignSpaceExplorationStoreAdapter.class);
 
                 objectiveStore = new ObjectivePriorityQueueImpl(storeAdapter.getObjectives());
-                Procedure<VersionWithObjectiveValue> whenAllActivationsVisited = x -> objectiveStore.remove(x);
+                Consumer<VersionWithObjectiveValue> whenAllActivationsVisited = x -> objectiveStore.remove(x);
                 activationStore = new ActivationStoreImpl(storeAdapter.getTransformations().size(), whenAllActivationsVisited);
                 solutionStore = new SolutionStoreImpl(50);
                 equivalenceClassStore = new FastEquivalenceClassStore(modelStore.getAdapter(StateCoderStoreAdapter.class)) {
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationAdapter.java
index 37448309..d326f1dd 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationAdapter.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationAdapter.java
@@ -7,25 +7,22 @@ package tools.refinery.store.dse.transition;
 
 import tools.refinery.store.adapter.ModelAdapter;
 import tools.refinery.store.dse.transition.internal.DesignSpaceExplorationBuilderImpl;
-import tools.refinery.store.map.Version;
-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();
         }
+
         List<Transformation> getTransformations();
+
         boolean checkAccept();
+
         boolean checkExclude();
+
         ObjectiveValue getObjectiveValue();
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationBuilder.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationBuilder.java
index 3855a20a..800cf8f7 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationBuilder.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationBuilder.java
@@ -12,14 +12,16 @@ import tools.refinery.store.dse.transition.objectives.Objective;
 import java.util.Collection;
 import java.util.List;
 
+// Builder pattern with methods returning {@code this} for convenience.
+@SuppressWarnings("UnusedReturnValue")
 public interface DesignSpaceExplorationBuilder extends ModelAdapterBuilder {
+        DesignSpaceExplorationBuilder transformation(Rule transformationRuleDefinition);
 
-        DesignSpaceExplorationBuilder transformation(TransformationRule transformationRuleDefinition);
-        default DesignSpaceExplorationBuilder transformations(TransformationRule... transformationRuleDefinitions) {
+        default DesignSpaceExplorationBuilder transformations(Rule... transformationRuleDefinitions) {
                 return transformations(List.of(transformationRuleDefinitions));
         }
 
-        default DesignSpaceExplorationBuilder transformations(Collection<? extends TransformationRule> transformationRules) {
+        default DesignSpaceExplorationBuilder transformations(Collection<? extends Rule> transformationRules) {
                 transformationRules.forEach(this::transformation);
                 return this;
         }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationStoreAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationStoreAdapter.java
index 5c8c7a4d..fb082fae 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationStoreAdapter.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/DesignSpaceExplorationStoreAdapter.java
@@ -17,7 +17,7 @@ public interface DesignSpaceExplorationStoreAdapter extends ModelStoreAdapter
         @Override
         DesignSpaceExplorationAdapter createModelAdapter(Model model);
 
-        List<TransformationRule> getTransformations();
+        List<Rule> getTransformations();
 
         List<Criterion> getAccepts();
 
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/Rule.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/Rule.java
new file mode 100644
index 00000000..ff45ed3e
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/Rule.java
@@ -0,0 +1,99 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition;
+
+import tools.refinery.store.dse.transition.actions.Action;
+import tools.refinery.store.dse.transition.actions.BoundAction;
+import tools.refinery.store.dse.transition.callback.*;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.dnf.RelationalQuery;
+
+public class Rule {
+        private final String name;
+        private final RelationalQuery precondition;
+        private final Action action;
+
+        public Rule(String name, RelationalQuery precondition, Action action) {
+                if (precondition.arity() != action.getArity()) {
+                        throw new IllegalArgumentException("Expected an action clause with %d parameters, got %d instead"
+                                        .formatted(precondition.arity(), action.getArity()));
+                }
+                this.name = name;
+                this.precondition = precondition;
+                this.action = action;
+        }
+
+        public String getName() {
+                return name;
+        }
+
+        public RelationalQuery getPrecondition() {
+                return precondition;
+        }
+
+        public BoundAction createAction(Model model) {
+                return action.bindToModel(model);
+        }
+
+        public static RuleBuilder builder(String name) {
+                return new RuleBuilder(name);
+        }
+
+        public static RuleBuilder builder() {
+                return builder(null);
+        }
+
+        public static Rule of(String name, RuleCallback0 callback) {
+                var builder = builder(name);
+                callback.accept(builder);
+                return builder.build();
+        }
+
+        public static Rule of(RuleCallback0 callback) {
+                return of(null, callback);
+        }
+
+        public static Rule of(String name, RuleCallback1 callback) {
+                var builder = builder(name);
+                callback.accept(builder, builder.parameter("p1"));
+                return builder.build();
+        }
+
+        public static Rule of(RuleCallback1 callback) {
+                return of(null, callback);
+        }
+
+        public static Rule of(String name, RuleCallback2 callback) {
+                var builder = builder(name);
+                callback.accept(builder, builder.parameter("p1"), builder.parameter("p2"));
+                return builder.build();
+        }
+
+        public static Rule of(RuleCallback2 callback) {
+                return of(null, callback);
+        }
+
+        public static Rule of(String name, RuleCallback3 callback) {
+                var builder = builder(name);
+                callback.accept(builder, builder.parameter("p1"), builder.parameter("p2"), builder.parameter("p3"));
+                return builder.build();
+        }
+
+        public static Rule of(RuleCallback3 callback) {
+                return of(null, callback);
+        }
+
+        public static Rule of(String name, RuleCallback4 callback) {
+                var builder = builder(name);
+                callback.accept(builder, builder.parameter("p1"), builder.parameter("p2"), builder.parameter("p3"),
+                                builder.parameter("p4"));
+                return builder.build();
+        }
+
+        public static Rule of(RuleCallback4 callback) {
+                return of(null, callback);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/RuleBuilder.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/RuleBuilder.java
new file mode 100644
index 00000000..865ac369
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/RuleBuilder.java
@@ -0,0 +1,71 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition;
+
+import tools.refinery.store.dse.transition.actions.Action;
+import tools.refinery.store.dse.transition.actions.ActionLiteral;
+import tools.refinery.store.dse.transition.callback.*;
+import tools.refinery.store.query.dnf.AbstractQueryBuilder;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.List;
+
+public class RuleBuilder extends AbstractQueryBuilder<RuleBuilder> {
+        private final String name;
+        private List<ActionLiteral> action;
+
+        RuleBuilder(String name) {
+                super(Dnf.builder(name == null ? null : name + "#precondition"));
+                this.name = name;
+        }
+
+        @Override
+        protected RuleBuilder self() {
+                return this;
+        }
+
+        public RuleBuilder action(ActionLiteral... literals) {
+                return action(List.of(literals));
+        }
+
+        public RuleBuilder action(List<? extends ActionLiteral> literals) {
+                if (this.action != null) {
+                        throw new IllegalStateException("Actions have already been set");
+                }
+                this.action = List.copyOf(literals);
+                return this;
+        }
+
+        public RuleBuilder action(Action action) {
+                return action(action.getActionLiterals());
+        }
+
+        public RuleBuilder action(ActionCallback0 callback) {
+                return action(callback.toLiterals());
+        }
+
+        public RuleBuilder action(ActionCallback1 callback) {
+                return action(callback.toLiterals(Variable.of("v1")));
+        }
+
+        public RuleBuilder action(ActionCallback2 callback) {
+                return action(callback.toLiterals(Variable.of("v1"), Variable.of("v2")));
+        }
+
+        public RuleBuilder action(ActionCallback3 callback) {
+                return action(callback.toLiterals(Variable.of("v1"), Variable.of("v2"), Variable.of("v3")));
+        }
+
+        public RuleBuilder action(ActionCallback4 callback) {
+                return action(callback.toLiterals(Variable.of("v1"), Variable.of("v2"), Variable.of("v3"), Variable.of("v4")));
+        }
+
+        public Rule build() {
+                var precondition = dnfBuilder.build().asRelation();
+                return new Rule(name, precondition, Action.ofPrecondition(precondition, action));
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/Transformation.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/Transformation.java
index 2cce738f..0eeccbdf 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/Transformation.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/Transformation.java
@@ -5,25 +5,27 @@
  */
 package tools.refinery.store.dse.transition;
 
-import org.eclipse.collections.api.block.procedure.Procedure;
+import tools.refinery.store.dse.transition.actions.BoundAction;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.ModelQueryAdapter;
 import tools.refinery.store.query.resultset.OrderedResultSet;
 import tools.refinery.store.query.resultset.ResultSet;
 import tools.refinery.store.tuple.Tuple;
 
 public class Transformation {
-        private final TransformationRule definition;
-
+        private final Rule definition;
         private final OrderedResultSet<Boolean> activations;
+        private final BoundAction action;
 
-        private final Procedure<Tuple> action;
-
-        public Transformation(TransformationRule definition, OrderedResultSet<Boolean> activations, Procedure<Tuple> action) {
+        public Transformation(Model model, Rule definition) {
                 this.definition = definition;
-                this.activations = activations;
-                this.action = action;
+                var precondition = definition.getPrecondition();
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+                activations = new OrderedResultSet<>(queryEngine.getResultSet(precondition));
+                action = definition.createAction(model);
         }
 
-        public TransformationRule getDefinition() {
+        public Rule getDefinition() {
                 return definition;
         }
 
@@ -36,8 +38,6 @@ public class Transformation {
         }
 
         public boolean fireActivation(Tuple activation) {
-                action.accept(activation);
-                //queryEngine.flushChanges();
-                return true;
+                return action.fire(activation);
         }
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/TransformationRule.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/TransformationRule.java
deleted file mode 100644
index d64a3db1..00000000
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/TransformationRule.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.dse.transition;
-
-import tools.refinery.store.model.Model;
-import tools.refinery.store.model.ModelStoreBuilder;
-import tools.refinery.store.query.ModelQueryAdapter;
-import tools.refinery.store.query.ModelQueryBuilder;
-import tools.refinery.store.query.dnf.RelationalQuery;
-import tools.refinery.store.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.*;
-
-public class TransformationRule {
-
-        private final String name;
-        private final RelationalQuery precondition;
-        private final ActionFactory actionFactory;
-
-        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 void doConfigure(ModelStoreBuilder storeBuilder) {
-                var queryBuilder = storeBuilder.getAdapter(ModelQueryBuilder.class);
-                queryBuilder.query(this.precondition);
-        }
-
-        public Transformation prepare(Model model) {
-                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
-                var activations = new OrderedResultSet<>(queryEngine.getResultSet(precondition));
-                var action = actionFactory.prepare(model);
-                return new Transformation(this,activations,action);
-        }
-
-        public String getName() {
-                return name;
-        }
-
-        public RelationalQuery getPrecondition() {
-                return precondition;
-        }
-
-}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/AbstractActionLiteral.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/AbstractActionLiteral.java
new file mode 100644
index 00000000..e30f06bb
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/AbstractActionLiteral.java
@@ -0,0 +1,9 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.actions;
+
+public abstract class AbstractActionLiteral implements ActionLiteral {
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/Action.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/Action.java
new file mode 100644
index 00000000..d63ddfdd
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/Action.java
@@ -0,0 +1,132 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.actions;
+
+import org.eclipse.collections.api.factory.primitive.ObjectIntMaps;
+import org.eclipse.collections.api.map.primitive.MutableObjectIntMap;
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.dnf.SymbolicParameter;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.*;
+
+public class Action {
+        private final List<NodeVariable> parameters;
+        private final Set<NodeVariable> localVariables;
+        private final List<ActionLiteral> actionLiterals;
+        private final int[] @Nullable [] inputAllocations;
+        private final int[] @Nullable [] outputAllocations;
+
+        public Action(List<NodeVariable> parameters, List<? extends ActionLiteral> actionLiterals) {
+                this.parameters = List.copyOf(parameters);
+                this.actionLiterals = List.copyOf(actionLiterals);
+                var allocation = ObjectIntMaps.mutable.<NodeVariable>empty();
+                int arity = parameters.size();
+                for (int i = 0; i < arity; i++) {
+                        allocation.put(parameters.get(i), i);
+                }
+                var mutableLocalVariables = new LinkedHashSet<NodeVariable>();
+                int size = actionLiterals.size();
+                inputAllocations = new int[size][];
+                outputAllocations = new int[size][];
+                for (int i = 0; i < size; i++) {
+                        computeInputAllocation(i, parameters, allocation);
+                        computeOutputAllocation(i, mutableLocalVariables, allocation);
+                }
+                this.localVariables = Collections.unmodifiableSet(mutableLocalVariables);
+        }
+
+        private void computeInputAllocation(int actionIndex, List<NodeVariable> parameters,
+                                                                                MutableObjectIntMap<NodeVariable> allocation) {
+                var actionLiteral = actionLiterals.get(actionIndex);
+                var inputVariables = actionLiteral.getInputVariables();
+                if (inputVariables.equals(parameters)) {
+                        // Identity mappings use a {@code null} allocation to pass the activation tuple unchanged.
+                        return;
+                }
+                var inputs = new int[inputVariables.size()];
+                for (int i = 0; i < inputs.length; i++) {
+                        var variable = inputVariables.get(i);
+                        if (!allocation.containsKey(variable)) {
+                                throw new IllegalArgumentException("Unbound input variable %s of action literal %s"
+                                                .formatted(variable, actionLiteral));
+                        }
+                        inputs[i] = allocation.get(variable);
+                }
+                inputAllocations[actionIndex] = inputs;
+        }
+
+        private void computeOutputAllocation(int actionIndex, Set<NodeVariable> mutableLocalVariable,
+                                                                                 MutableObjectIntMap<NodeVariable> allocation) {
+                var actionLiteral = actionLiterals.get(actionIndex);
+                var outputVariables = actionLiteral.getOutputVariables();
+                int size = outputVariables.size();
+                if (size == 0) {
+                        // Identity mappings use a {@code null} allocation to avoid iterating over the output tuple.
+                        return;
+                }
+                if (size >= 2 && new HashSet<>(outputVariables).size() != size) {
+                        throw new IllegalArgumentException("Action literal %s has duplicate output variables %s"
+                                        .formatted(actionLiteral, outputVariables));
+                }
+                int arity = parameters.size();
+                var outputs = new int[size];
+                for (int i = 0; i < size; i++) {
+                        var variable = outputVariables.get(i);
+                        if (allocation.containsKey(variable)) {
+                                throw new IllegalArgumentException("Output variable %s of action literal %s was already assigned"
+                                                .formatted(variable, actionLiteral));
+                        }
+                        int variableId = mutableLocalVariable.size();
+                        allocation.put(variable, arity + variableId);
+                        outputs[i] = variableId;
+                        mutableLocalVariable.add(variable);
+                }
+                outputAllocations[actionIndex] = outputs;
+        }
+
+        public List<NodeVariable> getParameters() {
+                return parameters;
+        }
+
+        public int getArity() {
+                return parameters.size();
+        }
+
+        public Set<NodeVariable> getLocalVariables() {
+                return localVariables;
+        }
+
+        public List<ActionLiteral> getActionLiterals() {
+                return actionLiterals;
+        }
+
+        int @Nullable [] getInputAllocation(int actionIndex) {
+                return inputAllocations[actionIndex];
+        }
+
+        int @Nullable [] getOutputAllocation(int actionIndex) {
+                return outputAllocations[actionIndex];
+        }
+
+        public BoundAction bindToModel(Model model) {
+                return new BoundAction(this, model);
+        }
+
+        public static Action ofSymbolicParameters(List<SymbolicParameter> symbolicParameters,
+                                                                                          List<? extends ActionLiteral> actionLiterals) {
+                var nodeVariables = symbolicParameters.stream()
+                                .map(symbolicParameter -> symbolicParameter.getVariable().asNodeVariable())
+                                .toList();
+                return new Action(nodeVariables, actionLiterals);
+        }
+
+        public static Action ofPrecondition(RelationalQuery precondition, List<? extends ActionLiteral> actionLiterals) {
+                return ofSymbolicParameters(precondition.getDnf().getSymbolicParameters(), actionLiterals);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/ActionLiteral.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/ActionLiteral.java
new file mode 100644
index 00000000..a721ef73
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/ActionLiteral.java
@@ -0,0 +1,19 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.actions;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.List;
+
+public interface ActionLiteral {
+        List<NodeVariable> getInputVariables();
+
+        List<NodeVariable> getOutputVariables();
+
+        BoundActionLiteral bindToModel(Model model);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/ActionLiterals.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/ActionLiterals.java
new file mode 100644
index 00000000..275e1e25
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/ActionLiterals.java
@@ -0,0 +1,33 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.actions;
+
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.representation.Symbol;
+
+import java.util.List;
+import java.util.Objects;
+
+public final class ActionLiterals {
+        private ActionLiterals() {
+                throw new IllegalArgumentException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static <T> PutActionLiteral<T> put(Symbol<T> symbol, T value, NodeVariable... parameters) {
+                return new PutActionLiteral<>(symbol, value, List.of(parameters));
+        }
+
+        public static PutActionLiteral<Boolean> add(Symbol<Boolean> symbol, NodeVariable... parameters) {
+                if (!Objects.equals(symbol.defaultValue(), false)) {
+                        throw new IllegalArgumentException("Use put to add a value to symbols other than two-valued logic");
+                }
+                return put(symbol, true, parameters);
+        }
+
+        public static <T> PutActionLiteral<T> remove(Symbol<T> symbol, NodeVariable... parameters) {
+                return put(symbol, symbol.defaultValue(), parameters);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/BoundAction.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/BoundAction.java
new file mode 100644
index 00000000..55f43735
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/BoundAction.java
@@ -0,0 +1,109 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.actions;
+
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+
+public class BoundAction {
+        private final Action action;
+        private final BoundActionLiteral[] boundLiterals;
+        private Tuple activation;
+        private final int[] localVariables;
+
+        BoundAction(Action action, Model model) {
+                this.action = action;
+                var actionLiterals = action.getActionLiterals();
+                int size = actionLiterals.size();
+                boundLiterals = new BoundActionLiteral[size];
+                for (int i = 0; i < size; i++) {
+                        boundLiterals[i] = actionLiterals.get(i).bindToModel(model);
+                }
+                localVariables = new int[action.getLocalVariables().size()];
+        }
+
+        public boolean fire(Tuple activation) {
+                if (this.activation != null) {
+                        throw new IllegalStateException("Reentrant firing is not allowed");
+                }
+                this.activation = activation;
+                try {
+                        int size = boundLiterals.length;
+                        for (int i = 0; i < size; i++) {
+                                var inputAllocation = action.getInputAllocation(i);
+                                var boundLiteral = boundLiterals[i];
+                                var input = getInputTuple(inputAllocation);
+                                var output = boundLiteral.fire(input);
+                                if (output == null) {
+                                        return false;
+                                }
+                                var outputAllocation = this.action.getOutputAllocation(i);
+                                setOutputTuple(outputAllocation, output);
+                        }
+                } finally {
+                        this.activation = null;
+                }
+                return true;
+        }
+
+        private Tuple getInputTuple(int @Nullable [] inputAllocation) {
+                if (inputAllocation == null) {
+                        // Identity allocation.
+                        return activation;
+                }
+                return switch (inputAllocation.length) {
+                        case 0 -> Tuple.of();
+                        case 1 -> Tuple.of(getInput(inputAllocation[0]));
+                        case 2 -> Tuple.of(getInput(inputAllocation[0]), getInput(inputAllocation[1]));
+                        case 3 -> Tuple.of(getInput(inputAllocation[0]), getInput(inputAllocation[1]),
+                                        getInput(inputAllocation[2]));
+                        case 4 -> Tuple.of(getInput(inputAllocation[0]), getInput(inputAllocation[1]),
+                                        getInput(inputAllocation[2]), getInput(inputAllocation[3]));
+                        default -> {
+                                var elements = new int[inputAllocation.length];
+                                for (var i = 0; i < inputAllocation.length; i++) {
+                                        elements[i] = getInput(inputAllocation[i]);
+                                }
+                                yield Tuple.of(elements);
+                        }
+                };
+        }
+
+        private int getInput(int index) {
+                int arity = action.getArity();
+                return index < arity ? activation.get(index) : localVariables[index - arity];
+        }
+
+        private void setOutputTuple(int @Nullable [] outputAllocation, Tuple output) {
+                if (outputAllocation == null || outputAllocation.length == 0) {
+                        return;
+                }
+                switch (outputAllocation.length) {
+                case 1 -> localVariables[outputAllocation[0]] = output.get(0);
+                case 2 -> {
+                        localVariables[outputAllocation[0]] = output.get(0);
+                        localVariables[outputAllocation[1]] = output.get(1);
+                }
+                case 3 -> {
+                        localVariables[outputAllocation[0]] = output.get(0);
+                        localVariables[outputAllocation[1]] = output.get(1);
+                        localVariables[outputAllocation[2]] = output.get(2);
+                }
+                case 4 -> {
+                        localVariables[outputAllocation[0]] = output.get(0);
+                        localVariables[outputAllocation[1]] = output.get(1);
+                        localVariables[outputAllocation[2]] = output.get(2);
+                        localVariables[outputAllocation[3]] = output.get(3);
+                }
+                default -> {
+                        for (int i = 0; i < outputAllocation.length; i++) {
+                                localVariables[outputAllocation[i]] = output.get(i);
+                        }
+                }
+                }
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/BoundActionLiteral.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/BoundActionLiteral.java
new file mode 100644
index 00000000..09c3c58c
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/BoundActionLiteral.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.actions;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.tuple.Tuple;
+
+@FunctionalInterface
+public interface BoundActionLiteral {
+        @Nullable
+        Tuple fire(@NotNull Tuple tuple);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/PutActionLiteral.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/PutActionLiteral.java
new file mode 100644
index 00000000..86288921
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/actions/PutActionLiteral.java
@@ -0,0 +1,64 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.actions;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.List;
+
+public class PutActionLiteral<T> extends AbstractActionLiteral {
+        private final Symbol<T> symbol;
+        private final List<NodeVariable> parameters;
+        private final T value;
+
+        public PutActionLiteral(Symbol<T> symbol, T value, List<NodeVariable> parameters) {
+                if (symbol.arity() != parameters.size()) {
+                        throw new IllegalArgumentException("Expected %d parameters for symbol %s, got %d instead"
+                                        .formatted(symbol.arity(), symbol, parameters.size()));
+                }
+                if (value != null && !symbol.valueType().isInstance(value)) {
+                        throw new IllegalArgumentException("Expected value of type %s for symbol %s, got %s of type %s instead"
+                                        .formatted(symbol.valueType().getName(), symbol, value, value.getClass().getName()));
+                }
+                this.symbol = symbol;
+                this.parameters = List.copyOf(parameters);
+                this.value = value;
+        }
+
+        public Symbol<T> getSymbol() {
+                return symbol;
+        }
+
+        public List<NodeVariable> getParameters() {
+                return parameters;
+        }
+
+        public T getValue() {
+                return value;
+        }
+
+        @Override
+        public List<NodeVariable> getInputVariables() {
+                return getParameters();
+        }
+
+        @Override
+        public List<NodeVariable> getOutputVariables() {
+                return List.of();
+        }
+
+        @Override
+        public BoundActionLiteral bindToModel(Model model) {
+                var interpretation = model.getInterpretation(symbol);
+                return tuple -> {
+                        interpretation.put(tuple, value);
+                        return Tuple.of();
+                };
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback0.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback0.java
new file mode 100644
index 00000000..1190fdeb
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback0.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.callback;
+
+import tools.refinery.store.dse.transition.actions.ActionLiteral;
+
+import java.util.List;
+
+@FunctionalInterface
+public interface ActionCallback0 {
+        List<ActionLiteral> toLiterals();
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback1.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback1.java
new file mode 100644
index 00000000..869f1a96
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback1.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.callback;
+
+import tools.refinery.store.dse.transition.actions.ActionLiteral;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.List;
+
+@FunctionalInterface
+public interface ActionCallback1 {
+        List<ActionLiteral> toLiterals(NodeVariable v1);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback2.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback2.java
new file mode 100644
index 00000000..a648fc93
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback2.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.callback;
+
+import tools.refinery.store.dse.transition.actions.ActionLiteral;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.List;
+
+@FunctionalInterface
+public interface ActionCallback2 {
+        List<ActionLiteral> toLiterals(NodeVariable v1, NodeVariable v2);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback3.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback3.java
new file mode 100644
index 00000000..a9b1d334
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback3.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.callback;
+
+import tools.refinery.store.dse.transition.actions.ActionLiteral;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.List;
+
+@FunctionalInterface
+public interface ActionCallback3 {
+        List<ActionLiteral> toLiterals(NodeVariable v1, NodeVariable v2, NodeVariable v3);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback4.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback4.java
new file mode 100644
index 00000000..aef1351c
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/ActionCallback4.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.callback;
+
+import tools.refinery.store.dse.transition.actions.ActionLiteral;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.List;
+
+@FunctionalInterface
+public interface ActionCallback4 {
+        List<ActionLiteral> toLiterals(NodeVariable v1, NodeVariable v2, NodeVariable v3, NodeVariable v4);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback0.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback0.java
new file mode 100644
index 00000000..538c23ba
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback0.java
@@ -0,0 +1,13 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.callback;
+
+import tools.refinery.store.dse.transition.RuleBuilder;
+
+@FunctionalInterface
+public interface RuleCallback0 {
+        void accept(RuleBuilder builder);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback1.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback1.java
new file mode 100644
index 00000000..bd7bf4f5
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback1.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.callback;
+
+import tools.refinery.store.dse.transition.RuleBuilder;
+import tools.refinery.store.query.term.NodeVariable;
+
+@FunctionalInterface
+public interface RuleCallback1 {
+        void accept(RuleBuilder builder, NodeVariable p1);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback2.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback2.java
new file mode 100644
index 00000000..7b02b68a
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback2.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.callback;
+
+import tools.refinery.store.dse.transition.RuleBuilder;
+import tools.refinery.store.query.term.NodeVariable;
+
+@FunctionalInterface
+public interface RuleCallback2 {
+        void accept(RuleBuilder builder, NodeVariable p1, NodeVariable p2);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback3.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback3.java
new file mode 100644
index 00000000..6f112d48
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback3.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.callback;
+
+import tools.refinery.store.dse.transition.RuleBuilder;
+import tools.refinery.store.query.term.NodeVariable;
+
+@FunctionalInterface
+public interface RuleCallback3 {
+        void accept(RuleBuilder builder, NodeVariable p1, NodeVariable p2, NodeVariable p3);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback4.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback4.java
new file mode 100644
index 00000000..dbcf8567
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/callback/RuleCallback4.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.callback;
+
+import tools.refinery.store.dse.transition.RuleBuilder;
+import tools.refinery.store.query.term.NodeVariable;
+
+@FunctionalInterface
+public interface RuleCallback4 {
+        void accept(RuleBuilder builder, NodeVariable p1, NodeVariable p2, NodeVariable p3, NodeVariable p4);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationBuilderImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationBuilderImpl.java
index 4371cc03..a91f6870 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationBuilderImpl.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationBuilderImpl.java
@@ -7,13 +7,13 @@ package tools.refinery.store.dse.transition.internal;
 
 import tools.refinery.store.adapter.AbstractModelAdapterBuilder;
 import tools.refinery.store.dse.transition.DesignSpaceExplorationBuilder;
-import tools.refinery.store.dse.transition.TransformationRule;
+import tools.refinery.store.dse.transition.Rule;
 import tools.refinery.store.dse.transition.objectives.Criterion;
 import tools.refinery.store.dse.transition.objectives.Objective;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.query.ModelQueryBuilder;
 
-import java.util.ArrayList;
 import java.util.LinkedHashSet;
 import java.util.List;
 
@@ -21,13 +21,13 @@ public class DesignSpaceExplorationBuilderImpl
                 extends AbstractModelAdapterBuilder<DesignSpaceExplorationStoreAdapterImpl>
                 implements DesignSpaceExplorationBuilder {
 
-        LinkedHashSet<TransformationRule> transformationRuleDefinitions = new LinkedHashSet<>();
+        LinkedHashSet<Rule> transformationRuleDefinitions = new LinkedHashSet<>();
         LinkedHashSet<Criterion> accepts = new LinkedHashSet<>();
         LinkedHashSet<Criterion> excludes = new LinkedHashSet<>();
         LinkedHashSet<Objective> objectives = new LinkedHashSet<>();
 
         @Override
-        public DesignSpaceExplorationBuilder transformation(TransformationRule transformationRuleDefinition) {
+        public DesignSpaceExplorationBuilder transformation(Rule transformationRuleDefinition) {
                 transformationRuleDefinitions.add(transformationRuleDefinition);
                 return this;
         }
@@ -53,23 +53,23 @@ public class DesignSpaceExplorationBuilderImpl
 
         @Override
         protected void doConfigure(ModelStoreBuilder storeBuilder) {
-                transformationRuleDefinitions.forEach(x -> x.doConfigure(storeBuilder));
-                accepts.forEach(x -> x.doConfigure(storeBuilder));
-                excludes.forEach(x -> x.doConfigure(storeBuilder));
-                objectives.forEach(x -> x.doConfigure(storeBuilder));
+                var queryEngine = storeBuilder.getAdapter(ModelQueryBuilder.class);
+                transformationRuleDefinitions.forEach(x -> queryEngine.query(x.getPrecondition()));
+                accepts.forEach(x -> x.configure(storeBuilder));
+                excludes.forEach(x -> x.configure(storeBuilder));
+                objectives.forEach(x -> x.configure(storeBuilder));
 
                 super.doConfigure(storeBuilder);
         }
 
         @Override
         protected DesignSpaceExplorationStoreAdapterImpl doBuild(ModelStore store) {
-                List<TransformationRule> transformationRuleDefinitiions1 = new ArrayList<>(transformationRuleDefinitions);
-                List<Criterion> accepts1 = new ArrayList<>(accepts);
-                List<Criterion> excludes1 = new ArrayList<>(excludes);
-                List<Objective> objectives1 = new ArrayList<>(objectives);
+                List<Rule> transformationRuleDefinitionsList = List.copyOf(transformationRuleDefinitions);
+                List<Criterion> acceptsList = List.copyOf(accepts);
+                List<Criterion> excludesList = List.copyOf(excludes);
+                List<Objective> objectivesList = List.copyOf(objectives);
 
-                return new DesignSpaceExplorationStoreAdapterImpl(store,
-                                transformationRuleDefinitiions1, accepts1,
-                                excludes1, objectives1);
+                return new DesignSpaceExplorationStoreAdapterImpl(store, transformationRuleDefinitionsList, acceptsList,
+                                excludesList, objectivesList);
         }
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationStoreAdapterImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationStoreAdapterImpl.java
index 3319e148..bd85e7a6 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationStoreAdapterImpl.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/internal/DesignSpaceExplorationStoreAdapterImpl.java
@@ -7,7 +7,7 @@ package tools.refinery.store.dse.transition.internal;
 
 import tools.refinery.store.dse.transition.DesignSpaceExplorationStoreAdapter;
 import tools.refinery.store.dse.transition.Transformation;
-import tools.refinery.store.dse.transition.TransformationRule;
+import tools.refinery.store.dse.transition.Rule;
 import tools.refinery.store.dse.transition.objectives.Criterion;
 import tools.refinery.store.dse.transition.objectives.CriterionCalculator;
 import tools.refinery.store.dse.transition.objectives.Objective;
@@ -20,18 +20,16 @@ import java.util.List;
 public class DesignSpaceExplorationStoreAdapterImpl implements DesignSpaceExplorationStoreAdapter {
         protected final ModelStore store;
 
-        protected final List<TransformationRule> transformationRuleDefinitions;
+        protected final List<Rule> ruleDefinitions;
         protected final List<Criterion> accepts;
         protected final List<Criterion> excludes;
         protected final List<Objective> objectives;
 
-        public DesignSpaceExplorationStoreAdapterImpl(ModelStore store,
-                                                                                                  List<TransformationRule> transformationRuleDefinitions,
-                                                                                                  List<Criterion> accepts, List<Criterion> excludes,
-                                                                                                  List<Objective> objectives) {
+        public DesignSpaceExplorationStoreAdapterImpl(
+                        ModelStore store, List<Rule> ruleDefinitions, List<Criterion> accepts, List<Criterion> excludes,
+                        List<Objective> objectives) {
                 this.store = store;
-
-                this.transformationRuleDefinitions = transformationRuleDefinitions;
+                this.ruleDefinitions = ruleDefinitions;
                 this.accepts = accepts;
                 this.excludes = excludes;
                 this.objectives = objectives;
@@ -44,25 +42,31 @@ public class DesignSpaceExplorationStoreAdapterImpl implements DesignSpaceExplor
 
         @Override
         public DesignSpaceExplorationAdapterImpl createModelAdapter(Model model) {
-                final List<Transformation> t = this.transformationRuleDefinitions.stream().map(x->x.prepare(model)).toList();
-                final List<CriterionCalculator> a = this.accepts.stream().map(x->x.createCalculator(model)).toList();
-                final List<CriterionCalculator> e = this.excludes.stream().map(x->x.createCalculator(model)).toList();
-                final List<ObjectiveCalculator> o = this.objectives.stream().map(x->x.createCalculator(model)).toList();
+                final List<Transformation> t = this.ruleDefinitions.stream()
+                                .map(x -> new Transformation(model, x))
+                                .toList();
+                final List<CriterionCalculator> a = this.accepts.stream().map(x -> x.createCalculator(model)).toList();
+                final List<CriterionCalculator> e = this.excludes.stream().map(x -> x.createCalculator(model)).toList();
+                final List<ObjectiveCalculator> o = this.objectives.stream().map(x -> x.createCalculator(model)).toList();
 
                 return new DesignSpaceExplorationAdapterImpl(model, this, t, a, e, o);
         }
+
         @Override
-        public List<TransformationRule> getTransformations() {
-                return transformationRuleDefinitions;
+        public List<Rule> getTransformations() {
+                return ruleDefinitions;
         }
+
         @Override
         public List<Criterion> getAccepts() {
                 return accepts;
         }
+
         @Override
         public List<Criterion> getExcludes() {
                 return excludes;
         }
+
         @Override
         public List<Objective> getObjectives() {
                 return objectives;
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/AndCriterion.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/AndCriterion.java
new file mode 100644
index 00000000..0ad2b7a4
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/AndCriterion.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.literal.Reduction;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public final class AndCriterion extends CompositeCriterion {
+        AndCriterion(Collection<? extends Criterion> criteria) {
+                super(criteria);
+        }
+
+        @Override
+        public Reduction getReduction(ModelStore store) {
+                for (var criterion : getCriteria()) {
+                        var reduction = criterion.getReduction(store);
+                        if (reduction == Reduction.ALWAYS_FALSE) {
+                                return Reduction.ALWAYS_FALSE;
+                        } else if (reduction == Reduction.NOT_REDUCIBLE) {
+                                return Reduction.NOT_REDUCIBLE;
+                        }
+                }
+                return Reduction.ALWAYS_TRUE;
+        }
+
+        @Override
+        public CriterionCalculator createCalculator(Model model) {
+                var calculators = new ArrayList<CriterionCalculator>();
+                for (var criterion : getCriteria()) {
+                        var reduction = criterion.getReduction(model.getStore());
+                        if (reduction == Reduction.ALWAYS_FALSE) {
+                                return () -> false;
+                        } else if (reduction == Reduction.NOT_REDUCIBLE) {
+                                calculators.add(criterion.createCalculator(model));
+                        }
+                }
+                return () -> {
+                        for (var calculator : calculators) {
+                                if (!calculator.isSatisfied()) {
+                                        return false;
+                                }
+                        }
+                        return true;
+                };
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CompositeCriterion.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CompositeCriterion.java
new file mode 100644
index 00000000..5746cc7e
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CompositeCriterion.java
@@ -0,0 +1,43 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.query.literal.Reduction;
+
+import java.util.*;
+
+public abstract sealed class CompositeCriterion implements Criterion permits AndCriterion, OrCriterion {
+        private final List<Criterion> criteria;
+
+        protected CompositeCriterion(Collection<? extends Criterion> criteria) {
+                var deDuplicatedCriteria = new LinkedHashSet<Criterion>();
+                for (var criterion : criteria) {
+                        if (criterion.getClass() == this.getClass()) {
+                                var childCriteria = ((CompositeCriterion) criterion).getCriteria();
+                                deDuplicatedCriteria.addAll(childCriteria);
+                        } else {
+                                deDuplicatedCriteria.add(criterion);
+                        }
+                }
+                this.criteria = List.copyOf(deDuplicatedCriteria);
+        }
+
+        public List<Criterion> getCriteria() {
+                return criteria;
+        }
+
+        @Override
+        public abstract Reduction getReduction(ModelStore store);
+
+        @Override
+        public void configure(ModelStoreBuilder storeBuilder) {
+                for (var criterion : criteria) {
+                        criterion.configure(storeBuilder);
+                }
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CompositeObjective.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CompositeObjective.java
new file mode 100644
index 00000000..192a824b
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CompositeObjective.java
@@ -0,0 +1,69 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreBuilder;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+public class CompositeObjective implements Objective {
+        private final List<Objective> objectives;
+
+        CompositeObjective(Collection<? extends Objective> objectives) {
+                var unwrappedObjectives = new ArrayList<Objective>();
+                for (var objective : objectives) {
+                        if (objective instanceof CompositeObjective compositeObjective) {
+                                unwrappedObjectives.addAll(compositeObjective.getObjectives());
+                        } else {
+                                unwrappedObjectives.add(objective);
+                        }
+                }
+                this.objectives = Collections.unmodifiableList(unwrappedObjectives);
+        }
+
+        public List<Objective> getObjectives() {
+                return objectives;
+        }
+
+        @Override
+        public boolean isAlwaysZero(ModelStore store) {
+                for (var objective : objectives) {
+                        if (!objective.isAlwaysZero(store)) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+
+        @Override
+        public ObjectiveCalculator createCalculator(Model model) {
+                var calculators = new ArrayList<ObjectiveCalculator>();
+                for (var objective : objectives) {
+                        if (!objective.isAlwaysZero(model.getStore())) {
+                                calculators.add(objective.createCalculator(model));
+                        }
+                }
+                return () -> {
+                        double value = 0;
+                        for (var calculator : calculators) {
+                                value += calculator.getValue();
+                        }
+                        return value;
+                };
+        }
+
+        @Override
+        public void configure(ModelStoreBuilder storeBuilder) {
+                for (var objective : objectives) {
+                        objective.configure(storeBuilder);
+                }
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CountObjective.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CountObjective.java
new file mode 100644
index 00000000..fbd05ded
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/CountObjective.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.ModelQueryBuilder;
+import tools.refinery.store.query.ModelQueryStoreAdapter;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.literal.Reduction;
+
+public class CountObjective implements Objective {
+        private final RelationalQuery query;
+        private final double weight;
+
+        public CountObjective(RelationalQuery query) {
+                this(query, 1);
+        }
+
+        public CountObjective(RelationalQuery query, double weight) {
+                this.query = query;
+                this.weight = weight;
+        }
+
+        @Override
+        public boolean isAlwaysZero(ModelStore store) {
+                var queryStore = store.getAdapter(ModelQueryStoreAdapter.class);
+                var canonicalQuery = queryStore.getCanonicalQuery(query);
+                return canonicalQuery.getDnf().getReduction() == Reduction.ALWAYS_FALSE;
+        }
+
+        @Override
+        public ObjectiveCalculator createCalculator(Model model) {
+                var resultSet = model.getAdapter(ModelQueryAdapter.class).getResultSet(query);
+                return () -> resultSet.size() * weight;
+        }
+
+        @Override
+        public void configure(ModelStoreBuilder storeBuilder) {
+                storeBuilder.getAdapter(ModelQueryBuilder.class).query(query);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criteria.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criteria.java
new file mode 100644
index 00000000..0e4ec5c9
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criteria.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.query.dnf.AnyQuery;
+
+import java.util.Collection;
+import java.util.List;
+
+public final class Criteria {
+        private Criteria() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static QueryCriterion whenHasMatch(AnyQuery query) {
+                return new QueryCriterion(query, true);
+        }
+
+        public static QueryCriterion whenNoMatch(AnyQuery query) {
+                return new QueryCriterion(query, false);
+        }
+
+        public static Criterion and(Criterion... criteria) {
+                return and(List.of(criteria));
+        }
+
+        public static Criterion and(Collection<? extends Criterion> criteria) {
+                if (criteria.size() == 1) {
+                        return criteria.iterator().next();
+                }
+                return new AndCriterion(criteria);
+        }
+
+        public static Criterion or(Criterion... criteria) {
+                return or(List.of(criteria));
+        }
+
+        public static Criterion or(Collection<? extends Criterion> criteria) {
+                if (criteria.size() == 1) {
+                        return criteria.iterator().next();
+                }
+                return new OrCriterion(criteria);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criterion.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criterion.java
index 66ca6f5e..c827f20e 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criterion.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Criterion.java
@@ -6,10 +6,17 @@
 package tools.refinery.store.dse.transition.objectives;
 
 import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.query.literal.Reduction;
 
 public interface Criterion {
-        default void doConfigure(ModelStoreBuilder storeBuilder) {
+        default void configure(ModelStoreBuilder storeBuilder) {
         }
+
+        default Reduction getReduction(ModelStore store) {
+                return Reduction.NOT_REDUCIBLE;
+        }
+
         CriterionCalculator createCalculator(Model model);
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objective.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objective.java
index b5924455..49c34d87 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objective.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objective.java
@@ -6,10 +6,18 @@
 package tools.refinery.store.dse.transition.objectives;
 
 import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreBuilder;
 
 public interface Objective {
-        default void doConfigure(ModelStoreBuilder storeBuilder) {
+        default void configure(ModelStoreBuilder storeBuilder) {
         }
+
+        // The name {@code isAlwaysZero} is more straightforward than something like {@code canBeNonZero}.
+        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+        default boolean isAlwaysZero(ModelStore store) {
+                return false;
+        }
+
         ObjectiveCalculator createCalculator(Model model);
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objectives.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objectives.java
new file mode 100644
index 00000000..e552d14c
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/Objectives.java
@@ -0,0 +1,41 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.query.dnf.FunctionalQuery;
+import tools.refinery.store.query.dnf.RelationalQuery;
+
+import java.util.Collection;
+import java.util.List;
+
+public final class Objectives {
+        private Objectives() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static CountObjective count(RelationalQuery query, double weight) {
+                return new CountObjective(query, weight);
+        }
+
+        public static CountObjective count(RelationalQuery query) {
+                return new CountObjective(query);
+        }
+
+        public static QueryObjective value(FunctionalQuery<? extends Number> query) {
+                return new QueryObjective(query);
+        }
+
+        public static Objective sum(Objective... objectives) {
+                return sum(List.of(objectives));
+        }
+
+        public static Objective sum(Collection<? extends Objective> objectives) {
+                if (objectives.size() == 1) {
+                        return objectives.iterator().next();
+                }
+                return new CompositeObjective(objectives);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/OrCriterion.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/OrCriterion.java
new file mode 100644
index 00000000..7a8d7778
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/OrCriterion.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.transition.objectives;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.literal.Reduction;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public final class OrCriterion extends CompositeCriterion {
+        OrCriterion(Collection<? extends Criterion> criteria) {
+                super(criteria);
+        }
+
+        @Override
+        public Reduction getReduction(ModelStore store) {
+                for (var criterion : getCriteria()) {
+                        var reduction = criterion.getReduction(store);
+                        if (reduction == Reduction.ALWAYS_TRUE) {
+                                return Reduction.ALWAYS_TRUE;
+                        } else if (reduction == Reduction.NOT_REDUCIBLE) {
+                                return Reduction.NOT_REDUCIBLE;
+                        }
+                }
+                return Reduction.ALWAYS_FALSE;
+        }
+
+        @Override
+        public CriterionCalculator createCalculator(Model model) {
+                var calculators = new ArrayList<CriterionCalculator>();
+                for (var criterion : getCriteria()) {
+                        var reduction = criterion.getReduction(model.getStore());
+                        if (reduction == Reduction.ALWAYS_TRUE) {
+                                return () -> true;
+                        } else if (reduction == Reduction.NOT_REDUCIBLE) {
+                                calculators.add(criterion.createCalculator(model));
+                        }
+                }
+                return () -> {
+                        for (var calculator : calculators) {
+                                if (calculator.isSatisfied()) {
+                                        return true;
+                                }
+                        }
+                        return false;
+                };
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryCriteria.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryCriterion.java
index e6dddd53..e15e4e41 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryCriteria.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryCriterion.java
@@ -6,39 +6,54 @@
 package tools.refinery.store.dse.transition.objectives;
 
 import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.query.ModelQueryAdapter;
 import tools.refinery.store.query.ModelQueryBuilder;
+import tools.refinery.store.query.ModelQueryStoreAdapter;
 import tools.refinery.store.query.dnf.AnyQuery;
+import tools.refinery.store.query.literal.Reduction;
 
-public class QueryCriteria implements Criterion {
+public class QueryCriterion implements Criterion {
         protected final boolean satisfiedIfHasMatch;
         protected final AnyQuery query;
 
         /**
          * Criteria based on the existence of matches evaluated on the model.
-         * @param query The query evaluated on the model.
+         *
+         * @param query               The query evaluated on the model.
          * @param satisfiedIfHasMatch If true, the criteria satisfied if the query has any match on the model. Otherwise,
          *                            the criteria satisfied if the query has no match on the model.
          */
-        public QueryCriteria(AnyQuery query, boolean satisfiedIfHasMatch) {
+        public QueryCriterion(AnyQuery query, boolean satisfiedIfHasMatch) {
                 this.query = query;
                 this.satisfiedIfHasMatch = satisfiedIfHasMatch;
         }
 
         @Override
+        public Reduction getReduction(ModelStore store) {
+                var queryStore = store.getAdapter(ModelQueryStoreAdapter.class);
+                var canonicalQuery = queryStore.getCanonicalQuery(query);
+                var reduction = canonicalQuery.getDnf().getReduction();
+                if (satisfiedIfHasMatch) {
+                        return reduction;
+                }
+                return reduction.negate();
+        }
+
+        @Override
         public CriterionCalculator createCalculator(Model model) {
                 var resultSet = model.getAdapter(ModelQueryAdapter.class).getResultSet(query);
-                if(satisfiedIfHasMatch) {
+                if (satisfiedIfHasMatch) {
                         return () -> resultSet.size() > 0;
                 } else {
-                        return () ->  resultSet.size() == 0;
+                        return () -> resultSet.size() == 0;
                 }
         }
 
         @Override
-        public void doConfigure(ModelStoreBuilder storeBuilder) {
-                Criterion.super.doConfigure(storeBuilder);
+        public void configure(ModelStoreBuilder storeBuilder) {
+                Criterion.super.configure(storeBuilder);
                 storeBuilder.getAdapter(ModelQueryBuilder.class).query(query);
         }
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryObjective.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryObjective.java
index dfddccfc..9f4bb536 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryObjective.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/objectives/QueryObjective.java
@@ -15,6 +15,10 @@ public class QueryObjective implements Objective {
         protected final FunctionalQuery<? extends Number> objectiveFunction;
 
         public QueryObjective(FunctionalQuery<? extends Number> objectiveFunction) {
+                if (objectiveFunction.arity() != 0) {
+                        throw new IllegalArgumentException("Objective functions must have 0 parameters, got %d instead"
+                                        .formatted(objectiveFunction.arity()));
+                }
                 this.objectiveFunction = objectiveFunction;
         }
 
@@ -23,22 +27,15 @@ public class QueryObjective implements Objective {
                 var resultSet = model.getAdapter(ModelQueryAdapter.class).getResultSet(objectiveFunction);
                 return () -> {
                         var cursor = resultSet.getAll();
-                        boolean hasElement = cursor.move();
-                        if(hasElement) {
-                                double result = cursor.getValue().doubleValue();
-                                if(cursor.move()) {
-                                        throw new IllegalStateException("Query providing the objective function has multiple values!");
-                                }
-                                return result;
-                        } else {
+                        if (!cursor.move()) {
                                 throw new IllegalStateException("Query providing the objective function has no values!");
                         }
+                        return cursor.getValue().doubleValue();
                 };
         }
 
         @Override
-        public void doConfigure(ModelStoreBuilder storeBuilder) {
-                Objective.super.doConfigure(storeBuilder);
+        public void configure(ModelStoreBuilder storeBuilder) {
                 storeBuilder.getAdapter(ModelQueryBuilder.class).query(objectiveFunction);
         }
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreImpl.java
index 9186741f..4d775b5a 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreImpl.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreImpl.java
@@ -5,19 +5,19 @@
  */
 package tools.refinery.store.dse.transition.statespace.internal;
 
-import org.eclipse.collections.api.block.procedure.Procedure;
 import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
 import tools.refinery.store.dse.transition.statespace.ActivationStore;
 
 import java.util.*;
+import java.util.function.Consumer;
 
 public class ActivationStoreImpl implements ActivationStore {
         final int numberOfTransformations;
-        final Procedure<VersionWithObjectiveValue> actionWhenAllActivationVisited;
+        final Consumer<VersionWithObjectiveValue> actionWhenAllActivationVisited;
         final Map<VersionWithObjectiveValue, List<ActivationStoreEntry>> versionToActivations;
 
         public ActivationStoreImpl(final int numberOfTransformations,
-                                                           Procedure<VersionWithObjectiveValue> actionWhenAllActivationVisited) {
+                                                           Consumer<VersionWithObjectiveValue> actionWhenAllActivationVisited) {
                 this.numberOfTransformations = numberOfTransformations;
                 this.actionWhenAllActivationVisited = actionWhenAllActivationVisited;
                 versionToActivations = new HashMap<>();
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreListEntry.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreListEntry.java
index 3d4cbfdc..14298bee 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreListEntry.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/ActivationStoreListEntry.java
@@ -5,14 +5,14 @@
  */
 package tools.refinery.store.dse.transition.statespace.internal;
 
-import org.eclipse.collections.impl.list.mutable.primitive.IntArrayList;
+import org.eclipse.collections.api.factory.primitive.IntLists;
+import org.eclipse.collections.api.list.primitive.MutableIntList;
 
 public class ActivationStoreListEntry extends ActivationStoreEntry {
-        IntArrayList visitedActivations;
+        private final MutableIntList visitedActivations = IntLists.mutable.empty();
 
         ActivationStoreListEntry(int numberOfActivations) {
                 super(numberOfActivations);
-                visitedActivations = new IntArrayList();
         }
 
         @Override
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/CompleteEquivalenceClassStore.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/CompleteEquivalenceClassStore.java
index 925e09a3..20a026b6 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/CompleteEquivalenceClassStore.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/CompleteEquivalenceClassStore.java
@@ -5,7 +5,8 @@
  */
 package tools.refinery.store.dse.transition.statespace.internal;
 
-import org.eclipse.collections.impl.map.mutable.primitive.IntObjectHashMap;
+import org.eclipse.collections.api.factory.primitive.IntObjectMaps;
+import org.eclipse.collections.api.map.primitive.MutableIntObjectMap;
 import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
 import tools.refinery.store.dse.transition.statespace.EquivalenceClassStore;
 import tools.refinery.store.statecoding.StateCoderResult;
@@ -27,11 +28,10 @@ public abstract class CompleteEquivalenceClassStore extends AbstractEquivalenceC
                 }
         }
 
-        final IntObjectHashMap<Object> modelCode2Versions;
+        private final MutableIntObjectMap<Object> modelCode2Versions = IntObjectMaps.mutable.empty();
 
         protected CompleteEquivalenceClassStore(StateCoderStoreAdapter stateCoderStoreAdapter) {
                 super(stateCoderStoreAdapter);
-                this.modelCode2Versions = new IntObjectHashMap<>();
         }
 
         @Override
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/FastEquivalenceClassStore.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/FastEquivalenceClassStore.java
index 6eba87d4..6d028124 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/FastEquivalenceClassStore.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/transition/statespace/internal/FastEquivalenceClassStore.java
@@ -5,7 +5,8 @@
  */
 package tools.refinery.store.dse.transition.statespace.internal;
 
-import org.eclipse.collections.impl.set.mutable.primitive.IntHashSet;
+import org.eclipse.collections.api.factory.primitive.IntSets;
+import org.eclipse.collections.api.set.primitive.MutableIntSet;
 import tools.refinery.store.dse.transition.VersionWithObjectiveValue;
 import tools.refinery.store.dse.transition.statespace.EquivalenceClassStore;
 import tools.refinery.store.statecoding.StateCoderResult;
@@ -13,11 +14,10 @@ import tools.refinery.store.statecoding.StateCoderStoreAdapter;
 
 public abstract class FastEquivalenceClassStore extends AbstractEquivalenceClassStore implements EquivalenceClassStore {
 
-        final IntHashSet codes;
+        private final MutableIntSet codes = IntSets.mutable.empty();
 
         protected FastEquivalenceClassStore(StateCoderStoreAdapter stateCoderStoreAdapter) {
                 super(stateCoderStoreAdapter);
-                this.codes = new IntHashSet();
         }
 
         @Override
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/CRAExamplesTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/CRAExamplesTest.java
index 831b9ff0..685b88bd 100644
--- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/CRAExamplesTest.java
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/CRAExamplesTest.java
@@ -7,19 +7,18 @@ package tools.refinery.store.dse;
 
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
+import tools.refinery.store.dse.modification.DanglingEdges;
 import tools.refinery.store.dse.modification.ModificationAdapter;
 import tools.refinery.store.dse.strategy.BestFirstStoreManager;
+import tools.refinery.store.dse.tests.DummyCriterion;
 import tools.refinery.store.dse.tests.DummyRandomCriterion;
 import tools.refinery.store.dse.tests.DummyRandomObjective;
 import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
-import tools.refinery.store.dse.tests.DummyCriterion;
-import tools.refinery.store.dse.tests.DummyObjective;
+import tools.refinery.store.dse.transition.Rule;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.ModelQueryAdapter;
-import tools.refinery.store.query.dnf.FunctionalQuery;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.dnf.RelationalQuery;
-import tools.refinery.store.dse.transition.TransformationRule;
 import tools.refinery.store.query.term.Variable;
 import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
 import tools.refinery.store.query.view.AnySymbolView;
@@ -32,195 +31,102 @@ import tools.refinery.visualization.internal.FileFormat;
 
 import java.util.List;
 
+import static tools.refinery.store.dse.modification.actions.ModificationActionLiterals.create;
+import static tools.refinery.store.dse.modification.actions.ModificationActionLiterals.delete;
+import static tools.refinery.store.dse.transition.actions.ActionLiterals.add;
+import static tools.refinery.store.dse.transition.actions.ActionLiterals.remove;
 import static tools.refinery.store.query.literal.Literals.not;
 
 class CRAExamplesTest {
-
         private static final Symbol<String> name = Symbol.of("Name", 1, String.class);
-
-//      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> attribute = Symbol.of("Attribute", 1);
         private static final Symbol<Boolean> method = Symbol.of("Method", 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> dataDependency = Symbol.of("DataDependency", 2);
         private static final Symbol<Boolean> functionalDependency = Symbol.of("FunctionalDependency", 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 attributeView = new KeyOnlyView<>(attribute);
         private static final AnySymbolView methodView = new KeyOnlyView<>(method);
-//      private static final AnySymbolView isEncapsulatedByView = new KeyOnlyView<>(isEncapsulatedBy);
         private static final AnySymbolView encapsulatesView = new KeyOnlyView<>(encapsulates);
-        private static final AnySymbolView dataDependencyView = new KeyOnlyView<>(dataDependency);
-        private static final AnySymbolView functionalDependencyView = new KeyOnlyView<>(functionalDependency);
-        private static final AnySymbolView featuresView = new KeyOnlyView<>(features);
-        private static final AnySymbolView classesView = new KeyOnlyView<>(classes);
 
-        /*Example Transformation rules*/
-        private static final RelationalQuery feature = Query.of("Feature",
-                        (builder, f) -> builder.clause(
-                                attributeView.call(f))
+        private static final RelationalQuery feature = Query.of("Feature", (builder, f) -> builder
                         .clause(
-                                methodView.call(f))
-                        );
-
-        private static final RelationalQuery assignFeaturePreconditionHelper = Query.of("AssignFeaturePreconditionHelper",
-                        (builder, c, f) -> builder.clause(
-                                        classElementView.call(c),
-//                                      classesView.call(model, c),
-                                        encapsulatesView.call(c, f)
+                                        attributeView.call(f)
+                        )
+                        .clause(
+                                        methodView.call(f)
                         ));
 
-        private static final RelationalQuery assignFeaturePrecondition = Query.of("AssignFeaturePrecondition",
-                        (builder, f, c1) -> builder.clause((c2) -> List.of(
-//                                      classModelView.call(model),
+        private static final Rule assignFeatureRule = Rule.of("AssignFeature", (builder, f, c1) -> builder
+                        .clause(
                                         feature.call(f),
                                         classElementView.call(c1),
-//                                      featuresView.call(model, f),
-                                        not(assignFeaturePreconditionHelper.call(c2, f)),
-                                        not(encapsulatesView.call(c1, f))
-                        )));
+                                        not(encapsulatesView.call(Variable.of(), f))
+                        )
+                        .action(
+                                        add(encapsulates, f, c1)
+                        ));
 
-        private static final RelationalQuery deleteEmptyClassPrecondition = Query.of("DeleteEmptyClassPrecondition",
-                        (builder, c) -> builder.clause((f) -> List.of(
-//                                      classModelView.call(model),
+        private static final Rule deleteEmptyClassRule = Rule.of("DeleteEmptyClass", (builder, c) -> builder
+                        .clause((f) -> List.of(
                                         classElementView.call(c),
-//                                      featuresView.call(model, f),
                                         not(encapsulatesView.call(c, f))
-                        )));
-
-        private static final RelationalQuery createClassPreconditionHelper = Query.of("CreateClassPreconditionHelper",
-                        (builder, f, c) -> builder.clause(
-                                        classElementView.call(c),
-//                                      classesView.call(model, c),
-                                        encapsulatesView.call(c, f)
+                        ))
+                        .action(
+                                        remove(classElement, c),
+                                        delete(c, DanglingEdges.IGNORE)
                         ));
 
-        private static final RelationalQuery createClassPrecondition = Query.of("CreateClassPrecondition",
-                        (builder, f) -> builder.clause((c) -> List.of(
-//                                      classModelView.call(model),
+        private static final Rule createClassRule = Rule.of("CreateClass", (builder, f) -> builder
+                        .clause((c) -> List.of(
                                         feature.call(f),
-                                        not(createClassPreconditionHelper.call(f, c))
+                                        not(encapsulatesView.call(f, c))
+                        ))
+                        .action((newClass) -> List.of(
+                                        create(newClass),
+                                        add(classElement, newClass),
+                                        add(encapsulates, newClass, f)
                         )));
 
-        private static final RelationalQuery moveFeaturePrecondition = Query.of("MoveFeature",
-                        (builder, c1, c2, f) -> builder.clause(
-//                                      classModelView.call(model),
+        private static final Rule moveFeatureRule = Rule.of("MoveFeature", (builder, c1, c2, f) -> builder
+                        .clause(
                                         classElementView.call(c1),
                                         classElementView.call(c2),
                                         c1.notEquivalent(c2),
                                         feature.call(f),
-//                                      classesView.call(model, c1),
-//                                      classesView.call(model, c2),
-//                                      featuresView.call(model, f),
                                         encapsulatesView.call(c1, f)
+                        )
+                        .action(
+                                        remove(encapsulates, c1, f),
+                                        add(encapsulates, c2, f)
                         ));
 
-        private static final TransformationRule assignFeatureRule = new TransformationRule("AssignFeature",
-                        assignFeaturePrecondition,
-                        (model) -> {
-//                              var isEncapsulatedByInterpretation = model.getInterpretation(isEncapsulatedBy);
-                                var encapsulatesInterpretation = model.getInterpretation(encapsulates);
-                                return ((Tuple activation) -> {
-                                        var feature = activation.get(0);
-                                        var classElement = activation.get(1);
-
-//                                      isEncapsulatedByInterpretation.put(Tuple.of(feature, classElement), true);
-                                        encapsulatesInterpretation.put(Tuple.of(classElement, feature), true);
-                                });
-                        });
-
-        private static final TransformationRule deleteEmptyClassRule = new TransformationRule("DeleteEmptyClass",
-                        deleteEmptyClassPrecondition,
-                        (model) -> {
-//                              var classesInterpretation = model.getInterpretation(classes);
-                                var classElementInterpretation = model.getInterpretation(classElement);
-                                return ((Tuple activation) -> {
-                                        // TODO: can we move modificationAdapter outside?
-                                        var modificationAdapter = model.getAdapter(ModificationAdapter.class);
-//                                      var modelElement = activation.get(0);
-                                        var classElement = activation.get(0);
-
-//                                      classesInterpretation.put(Tuple.of(modelElement, classElement), false);
-                                        classElementInterpretation.put(Tuple.of(classElement), false);
-                                        modificationAdapter.deleteObject(Tuple.of(classElement));
-                                });
-                        });
-
-        private static final TransformationRule createClassRule = new TransformationRule("CreateClass",
-                        createClassPrecondition,
-                        (model) -> {
-                                var classElementInterpretation = model.getInterpretation(classElement);
-//                              var classesInterpretation = model.getInterpretation(classes);
-                                var encapsulatesInterpretation = model.getInterpretation(encapsulates);
-                                return ((Tuple activation) -> {
-                                        // TODO: can we move modificationAdapter outside?
-                                        var modificationAdapter = model.getAdapter(ModificationAdapter.class);
-//                                      var modelElement = activation.get(0);
-                                        var feature = activation.get(0);
-
-                                        var newClassElement = modificationAdapter.createObject();
-                                        var newClassElementId = newClassElement.get(0);
-                                        classElementInterpretation.put(newClassElement, true);
-//                                      classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-                                        encapsulatesInterpretation.put(Tuple.of(newClassElementId, feature), true);
-                                });
-                        });
-
-        private static final TransformationRule moveFeatureRule = new TransformationRule("MoveFeature",
-                        moveFeaturePrecondition,
-                        (model) -> {
-                                var encapsulatesInterpretation = model.getInterpretation(encapsulates);
-                                return ((Tuple activation) -> {
-                                        var classElement1 = activation.get(0);
-                                        var classElement2 = activation.get(1);
-                                        var feature = activation.get(2);
-
-                                        encapsulatesInterpretation.put(Tuple.of(classElement1, feature), false);
-                                        encapsulatesInterpretation.put(Tuple.of(classElement2, feature), true);
-                                });
-                        });
-
         @Test
         @Disabled("This test is only for debugging purposes")
         void craTest() {
                 var store = ModelStore.builder()
-                                .symbols(classElement, encapsulates, classes, features, attribute, method, dataDependency,
-                                                functionalDependency, name)
-                                .with(ViatraModelQueryAdapter.builder()
-                                                .queries(feature, assignFeaturePreconditionHelper, assignFeaturePrecondition,
-                                                                deleteEmptyClassPrecondition, createClassPreconditionHelper, createClassPrecondition,
-                                                                moveFeaturePrecondition))
+                                .symbols(classElement, encapsulates, attribute, method, dataDependency, functionalDependency, name)
+                                .with(ViatraModelQueryAdapter.builder())
                                 .with(ModelVisualizerAdapter.builder()
                                                 .withOutputpath("test_output")
                                                 .withFormat(FileFormat.DOT)
                                                 .withFormat(FileFormat.SVG)
                                                 .saveStates()
-                                                .saveDesignSpace()
-                                )
+                                                .saveDesignSpace())
                                 .with(StateCoderAdapter.builder())
                                 .with(ModificationAdapter.builder())
                                 .with(DesignSpaceExplorationAdapter.builder()
                                                 .transformations(assignFeatureRule, deleteEmptyClassRule, createClassRule, moveFeatureRule)
                                                 .objectives(new DummyRandomObjective())
                                                 .accept(new DummyRandomCriterion())
-                                                .exclude(new DummyCriterion(false))
-                                )
+                                                .exclude(new DummyCriterion(false)))
                                 .build();
 
                 var model = store.createEmptyModel();
-//              modificationAdapter.setRandom(1);
                 var queryEngine = model.getAdapter(ModelQueryAdapter.class);
 
-//              var modelInterpretation = model.getInterpretation(classModel);
                 var nameInterpretation = model.getInterpretation(name);
                 var methodInterpretation = model.getInterpretation(method);
                 var attributeInterpretation = model.getInterpretation(attribute);
@@ -229,7 +135,6 @@ class CRAExamplesTest {
 
                 var modificationAdapter = model.getAdapter(ModificationAdapter.class);
 
-//              var modelElement = modificationAdapter.createObject();
                 var method1 = modificationAdapter.createObject();
                 var method1Id = method1.get(0);
                 var method2 = modificationAdapter.createObject();
@@ -259,9 +164,6 @@ class CRAExamplesTest {
                 nameInterpretation.put(attribute4, "A4");
                 nameInterpretation.put(attribute5, "A5");
 
-
-
-//              modelInterpretation.put(modelElement, true);
                 methodInterpretation.put(method1, true);
                 methodInterpretation.put(method2, true);
                 methodInterpretation.put(method3, true);
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DebugTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DebugTest.java
index 87c3892a..baa7c8a4 100644
--- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DebugTest.java
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DebugTest.java
@@ -9,110 +9,73 @@ import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.dse.modification.ModificationAdapter;
 import tools.refinery.store.dse.strategy.BestFirstStoreManager;
-import tools.refinery.store.dse.tests.DummyCriterion;
-import tools.refinery.store.dse.tests.DummyObjective;
 import tools.refinery.store.dse.tests.DummyRandomCriterion;
 import tools.refinery.store.dse.tests.DummyRandomObjective;
 import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
-import tools.refinery.store.dse.transition.TransformationRule;
+import tools.refinery.store.dse.transition.Rule;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.ModelQueryAdapter;
-import tools.refinery.store.query.dnf.Query;
 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.statecoding.StateCoderAdapter;
-import tools.refinery.store.tuple.Tuple;
 import tools.refinery.visualization.ModelVisualizerAdapter;
 import tools.refinery.visualization.internal.FileFormat;
 
+import java.util.List;
+
+import static tools.refinery.store.dse.modification.actions.ModificationActionLiterals.create;
+import static tools.refinery.store.dse.transition.actions.ActionLiterals.add;
+
 class DebugTest {
         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
         @Disabled("This test is only for debugging purposes")
         void BFSTest() {
-                var createClassPrecondition = Query.of("CreateClassPrecondition",
-                                (builder, model) -> builder.clause(
+                var createClassRule = Rule.of("CreateClass", (builder, model) -> builder
+                                .clause(
                                                 classModelView.call(model)
-                                ));
-
-                var createClassRule = new TransformationRule("CreateClass",
-                                createClassPrecondition,
-                                (model) -> {
-                                        var classesInterpretation = model.getInterpretation(classes);
-                                        var classElementInterpretation = model.getInterpretation(classElement);
-                                        return ((Tuple activation) -> {
-                                                var dseAdapter = model.getAdapter(ModificationAdapter.class);
-                                                var modelElement = activation.get(0);
-
-                                                var newClassElement = dseAdapter.createObject();
-                                                var newClassElementId = newClassElement.get(0);
-
-                                                classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-                                                classElementInterpretation.put(Tuple.of(newClassElementId), true);
-                                        });
-                                });
-
-                var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
-                                (builder, model) -> builder.clause(
+                                )
+                                .action((newClassElement) -> List.of(
+                                                create(newClassElement),
+                                                add(classElement, newClassElement),
+                                                add(classes, model, newClassElement)
+                                )));
+
+                var createFeatureRule = Rule.of("CreateFeature", (builder, model) -> builder
+                                .clause(
                                                 classModelView.call(model)
-                                ));
-
-                var createFeatureRule = new TransformationRule("CreateFeature",
-                                createFeaturePrecondition,
-                                (model) -> {
-                                        var featuresInterpretation = model.getInterpretation(features);
-                                        var featureInterpretation = model.getInterpretation(feature);
-                                        return ((Tuple activation) -> {
-                                                var dseAdapter = model.getAdapter(ModificationAdapter.class);
-                                                var modelElement = activation.get(0);
-
-                                                var newClassElement = dseAdapter.createObject();
-                                                var newClassElementId = newClassElement.get(0);
-
-                                                featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-                                                featureInterpretation.put(Tuple.of(newClassElementId), true);
-                                        });
-                                });
+                                )
+                                .action((newFeature) -> List.of(
+                                                create(newFeature),
+                                                add(feature, newFeature),
+                                                add(features, model, newFeature)
+                                )));
 
                 var store = ModelStore.builder()
-                                .symbols(classModel, classElement, feature, isEncapsulatedBy, encapsulates, classes, features)
-                                .with(ViatraModelQueryAdapter.builder()
-                                                .queries(createClassPrecondition, createFeaturePrecondition))
+                                .symbols(classModel, classElement, feature, classes, features)
+                                .with(ViatraModelQueryAdapter.builder())
                                 .with(ModelVisualizerAdapter.builder()
                                                 .withOutputpath("test_output")
                                                 .withFormat(FileFormat.DOT)
                                                 .withFormat(FileFormat.SVG)
                                                 .saveStates()
-                                                .saveDesignSpace()
-                                )
+                                                .saveDesignSpace())
                                 .with(StateCoderAdapter.builder())
                                 .with(ModificationAdapter.builder())
                                 .with(DesignSpaceExplorationAdapter.builder()
                                                 .transformations(createClassRule, createFeatureRule)
                                                 .objectives(new DummyRandomObjective())
                                                 .accept(new DummyRandomCriterion())
-                                                .exclude(new DummyRandomCriterion())
-                                )
+                                                .exclude(new DummyRandomCriterion()))
                                 .build();
 
                 var model = store.createEmptyModel();
@@ -128,11 +91,9 @@ class DebugTest {
                 var initialVersion = model.commit();
                 queryEngine.flushChanges();
 
-
                 var bestFirst = new BestFirstStoreManager(store);
                 bestFirst.startExploration(initialVersion);
                 var resultStore = bestFirst.getSolutionStore();
                 System.out.println("states size: " + resultStore.getSolutions().size());
-
         }
 }
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DesignSpaceExplorationTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DesignSpaceExplorationTest.java
deleted file mode 100644
index f5f13433..00000000
--- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/DesignSpaceExplorationTest.java
+++ /dev/null
@@ -1,596 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.dse;
-
-import tools.refinery.store.query.view.AnySymbolView;
-import tools.refinery.store.query.view.KeyOnlyView;
-import tools.refinery.store.representation.Symbol;
-
-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()
-//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)))
-//                              .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()
-//                                              .strategy(new DepthFirstStrategy()))
-//                              .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());
-//      }
-//
-//      @Test
-//      void DFSTrivialTest() {
-//              var store = ModelStore.builder()
-//                              .symbols(classModel)
-//                              .with(ViatraModelQueryAdapter.builder())
-//                              .with(DesignSpaceExplorationAdapter.builder()
-//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)))
-//                              .build();
-//
-//              var model = store.createEmptyModel();
-//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//
-//              var states = dseAdapter.explore();
-//              assertEquals(1, states.size());
-//      }
-//
-//      @Test
-//      void DFSOneRuleTest() {
-//              var createClassPrecondition = Query.of("CreateClassPrecondition",
-//                              (builder, model) -> builder.clause(
-//                                              classModelView.call(model)
-//                              ));
-//
-//              var createClassRule = new TransformationRule("CreateClass",
-//                              createClassPrecondition,
-//                              (model) -> {
-//                                      var classesInterpretation = model.getInterpretation(classes);
-//                                      var classElementInterpretation = model.getInterpretation(classElement);
-//                                      return ((Tuple activation) -> {
-//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//                                              var modelElement = activation.get(0);
-//
-//                                              var newClassElement = dseAdapter.createObject();
-//                                              var newClassElementId = newClassElement.get(0);
-//
-//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
-//                                      });
-//                              });
-//
-//              var store = ModelStore.builder()
-//                              .symbols(classModel, classElement, classes)
-//                              .with(ViatraModelQueryAdapter.builder()
-//                                              .queries(createClassPrecondition))
-//                              .with(DesignSpaceExplorationAdapter.builder()
-//                                              .transformations(createClassRule)
-//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)
-//                                              ))
-//                              .build();
-//
-//              var model = store.createEmptyModel();
-//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
-//
-//              var modelElementInterpretation = model.getInterpretation(classModel);
-//              modelElementInterpretation.put(dseAdapter.createObject(), true);
-//              queryEngine.flushChanges();
-//
-//              var states = dseAdapter.explore();
-//              assertEquals(1, states.size());
-//      }
-//
-//      @Test
-//      void DFSContinueTest() {
-//              var createClassPrecondition = Query.of("CreateClassPrecondition",
-//                              (builder, model) -> builder.clause(
-//                                              classModelView.call(model)
-//                              ));
-//
-//              var createClassRule = new TransformationRule("CreateClass",
-//                              createClassPrecondition,
-//                              (model) -> {
-//                                      var classesInterpretation = model.getInterpretation(classes);
-//                                      var classElementInterpretation = model.getInterpretation(classElement);
-//                                      return ((Tuple activation) -> {
-//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//                                              var modelElement = activation.get(0);
-//
-//                                              var newClassElement = dseAdapter.createObject();
-//                                              var newClassElementId = newClassElement.get(0);
-//
-//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
-//                                      });
-//                              });
-//
-//              var store = ModelStore.builder()
-//                              .symbols(classModel, classElement, classes)
-//                              .with(ViatraModelQueryAdapter.builder()
-//                                              .queries(createClassPrecondition))
-//                              .with(DesignSpaceExplorationAdapter.builder()
-//                                              .transformations(createClassRule)
-//                                              .strategy(new DepthFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
-//                                              ))
-//                              .build();
-//
-//              var model = store.createEmptyModel();
-//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
-//
-//              var modelElementInterpretation = model.getInterpretation(classModel);
-//              modelElementInterpretation.put(dseAdapter.createObject(), true);
-//              queryEngine.flushChanges();
-//
-//              var states = dseAdapter.explore();
-//              assertEquals(5, states.size());
-//      }
-//
-//      @Test
-//      void DFSCompletenessTest() {
-//              var createClassPrecondition = Query.of("CreateClassPrecondition",
-//                              (builder, model) -> builder.clause(
-//                                              classModelView.call(model)
-//                              ));
-//
-//              var createClassRule = new TransformationRule("CreateClass",
-//                              createClassPrecondition,
-//                              (model) -> {
-//                                      var classesInterpretation = model.getInterpretation(classes);
-//                                      var classElementInterpretation = model.getInterpretation(classElement);
-//                                      return ((Tuple activation) -> {
-//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//                                              var modelElement = activation.get(0);
-//
-//                                              var newClassElement = dseAdapter.createObject();
-//                                              var newClassElementId = newClassElement.get(0);
-//
-//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
-//                                      });
-//                              });
-//
-//              var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
-//                              (builder, model) -> builder.clause(
-//                                              classModelView.call(model)
-//                              ));
-//
-//              var createFeatureRule = new TransformationRule("CreateFeature",
-//                              createFeaturePrecondition,
-//                              (model) -> {
-//                                      var featuresInterpretation = model.getInterpretation(features);
-//                                      var featureInterpretation = model.getInterpretation(feature);
-//                                      return ((Tuple activation) -> {
-//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//                                              var modelElement = activation.get(0);
-//
-//                                              var newClassElement = dseAdapter.createObject();
-//                                              var newClassElementId = newClassElement.get(0);
-//
-//                                              featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-//                                              featureInterpretation.put(Tuple.of(newClassElementId), true);
-//                                      });
-//                              });
-//
-//              var store = ModelStore.builder()
-//                              .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
-//                              .with(ViatraModelQueryAdapter.builder()
-//                                              .queries(createClassPrecondition, createFeaturePrecondition))
-//                              .with(DesignSpaceExplorationAdapter.builder()
-//                                              .transformations(createClassRule, createFeatureRule)
-//                                              .strategy(new DepthFirstStrategy().withDepthLimit(10).continueIfHardObjectivesFulfilled()
-//                                              ))
-//                              .build();
-//
-//              var model = store.createEmptyModel();
-//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
-//
-//              var modelElementInterpretation = model.getInterpretation(classModel);
-//              modelElementInterpretation.put(dseAdapter.createObject(), true);
-//              queryEngine.flushChanges();
-//
-//              var states = dseAdapter.explore();
-//              assertEquals(2047, states.size());
-//      }
-//
-//      @Test
-//      void DFSSolutionLimitTest() {
-//              var createClassPrecondition = Query.of("CreateClassPrecondition",
-//                              (builder, model) -> builder.clause(
-//                                              classModelView.call(model)
-//                              ));
-//
-//              var createClassRule = new TransformationRule("CreateClass",
-//                              createClassPrecondition,
-//                              (model) -> {
-//                                      var classesInterpretation = model.getInterpretation(classes);
-//                                      var classElementInterpretation = model.getInterpretation(classElement);
-//                                      return ((Tuple activation) -> {
-//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//                                              var modelElement = activation.get(0);
-//
-//                                              var newClassElement = dseAdapter.createObject();
-//                                              var newClassElementId = newClassElement.get(0);
-//
-//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
-//                                      });
-//                              });
-//
-//              var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
-//                              (builder, model) -> builder.clause(
-//                                              classModelView.call(model)
-//                              ));
-//
-//              var createFeatureRule = new TransformationRule("CreateFeature",
-//                              createFeaturePrecondition,
-//                              (model) -> {
-//                                      var featuresInterpretation = model.getInterpretation(features);
-//                                      var featureInterpretation = model.getInterpretation(feature);
-//                                      return ((Tuple activation) -> {
-//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//                                              var modelElement = activation.get(0);
-//
-//                                              var newClassElement = dseAdapter.createObject();
-//                                              var newClassElementId = newClassElement.get(0);
-//
-//                                              featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-//                                              featureInterpretation.put(Tuple.of(newClassElementId), true);
-//                                      });
-//                              });
-//
-//              var store = ModelStore.builder()
-//                              .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
-//                              .with(ViatraModelQueryAdapter.builder()
-//                                              .queries(createClassPrecondition, createFeaturePrecondition))
-//                              .with(DesignSpaceExplorationAdapter.builder()
-//                                              .transformations(createClassRule, createFeatureRule)
-//                                              .strategy(new DepthFirstStrategy().withSolutionLimit(222)
-//                                                              .continueIfHardObjectivesFulfilled()
-//                                              ))
-//                              .build();
-//
-//              var model = store.createEmptyModel();
-//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
-//
-//              var modelElementInterpretation = model.getInterpretation(classModel);
-//              modelElementInterpretation.put(dseAdapter.createObject(), true);
-//              queryEngine.flushChanges();
-//
-//              var states = dseAdapter.explore();
-//              assertEquals(222, states.size());
-//      }
-//
-//      @Test
-//      void BeFSTrivialTest() {
-//              var store = ModelStore.builder()
-//                              .symbols(classModel)
-//                              .with(ViatraModelQueryAdapter.builder())
-//                              .with(DesignSpaceExplorationAdapter.builder()
-//                                              .strategy(new BestFirstStrategy().withDepthLimit(0)))
-//                              .build();
-//
-//              var model = store.createEmptyModel();
-//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//
-//              var states = dseAdapter.explore();
-//              assertEquals(1, states.size());
-//      }
-//
-//      @Test
-//      void BeFSOneRuleTest() {
-//              var createClassPrecondition = Query.of("CreateClassPrecondition",
-//                              (builder, model) -> builder.clause(
-//                                              classModelView.call(model)
-//                              ));
-//
-//              var createClassRule = new TransformationRule("CreateClass",
-//                              createClassPrecondition,
-//                              (model) -> {
-//                                      var classesInterpretation = model.getInterpretation(classes);
-//                                      var classElementInterpretation = model.getInterpretation(classElement);
-//                                      return ((Tuple activation) -> {
-//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//                                              var modelElement = activation.get(0);
-//
-//                                              var newClassElement = dseAdapter.createObject();
-//                                              var newClassElementId = newClassElement.get(0);
-//
-//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
-//                                      });
-//                              });
-//
-//              var store = ModelStore.builder()
-//                              .symbols(classModel, classElement, classes)
-//                              .with(ViatraModelQueryAdapter.builder()
-//                                              .queries(createClassPrecondition))
-//                              .with(DesignSpaceExplorationAdapter.builder()
-//                                              .transformations(createClassRule)
-//                                              .strategy(new BestFirstStrategy().withDepthLimit(4)
-//                                              ))
-//                              .build();
-//
-//              var model = store.createEmptyModel();
-//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
-//
-//              var modelElementInterpretation = model.getInterpretation(classModel);
-//              modelElementInterpretation.put(dseAdapter.createObject(), true);
-//              queryEngine.flushChanges();
-//
-//              var states = dseAdapter.explore();
-//              assertEquals(1, states.size());
-//      }
-//
-//      @Test
-//      void BeFSContinueTest() {
-//              var createClassPrecondition = Query.of("CreateClassPrecondition",
-//                              (builder, model) -> builder.clause(
-//                                              classModelView.call(model)
-//                              ));
-//
-//              var createClassRule = new TransformationRule("CreateClass",
-//                              createClassPrecondition,
-//                              (model) -> {
-//                                      var classesInterpretation = model.getInterpretation(classes);
-//                                      var classElementInterpretation = model.getInterpretation(classElement);
-//                                      return ((Tuple activation) -> {
-//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//                                              var modelElement = activation.get(0);
-//
-//                                              var newClassElement = dseAdapter.createObject();
-//                                              var newClassElementId = newClassElement.get(0);
-//
-//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
-//                                      });
-//                              });
-//
-//              var store = ModelStore.builder()
-//                              .symbols(classModel, classElement, classes)
-//                              .with(ViatraModelQueryAdapter.builder()
-//                                              .queries(createClassPrecondition))
-//                              .with(DesignSpaceExplorationAdapter.builder()
-//                                              .transformations(createClassRule)
-//                                              .strategy(new BestFirstStrategy().withDepthLimit(4).continueIfHardObjectivesFulfilled()
-//                                              ))
-//                              .build();
-//
-//              var model = store.createEmptyModel();
-//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
-//
-//              var modelElementInterpretation = model.getInterpretation(classModel);
-//              modelElementInterpretation.put(dseAdapter.createObject(), true);
-//              queryEngine.flushChanges();
-//
-//              var states = dseAdapter.explore();
-//              assertEquals(5, states.size());
-//      }
-//
-//      @Test
-//      void BeFSCompletenessTest() {
-//              var createClassPrecondition = Query.of("CreateClassPrecondition",
-//                              (builder, model) -> builder.clause(
-//                                              classModelView.call(model)
-//                              ));
-//
-//              var createClassRule = new TransformationRule("CreateClass",
-//                              createClassPrecondition,
-//                              (model) -> {
-//                                      var classesInterpretation = model.getInterpretation(classes);
-//                                      var classElementInterpretation = model.getInterpretation(classElement);
-//                                      return ((Tuple activation) -> {
-//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//                                              var modelElement = activation.get(0);
-//
-//                                              var newClassElement = dseAdapter.createObject();
-//                                              var newClassElementId = newClassElement.get(0);
-//
-//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
-//                                      });
-//                              });
-//
-//              var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
-//                              (builder, model) -> builder.clause(
-//                                              classModelView.call(model)
-//                              ));
-//
-//              var createFeatureRule = new TransformationRule("CreateFeature",
-//                              createFeaturePrecondition,
-//                              (model) -> {
-//                                      var featuresInterpretation = model.getInterpretation(features);
-//                                      var featureInterpretation = model.getInterpretation(feature);
-//                                      return ((Tuple activation) -> {
-//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//                                              var modelElement = activation.get(0);
-//
-//                                              var newClassElement = dseAdapter.createObject();
-//                                              var newClassElementId = newClassElement.get(0);
-//
-//                                              featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-//                                              featureInterpretation.put(Tuple.of(newClassElementId), true);
-//                                      });
-//                              });
-//
-//              var store = ModelStore.builder()
-//                              .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
-//                              .with(ViatraModelQueryAdapter.builder()
-//                                              .queries(createClassPrecondition, createFeaturePrecondition))
-//                              .with(DesignSpaceExplorationAdapter.builder()
-//                                              .transformations(createClassRule, createFeatureRule)
-//                                              .strategy(new BestFirstStrategy().withDepthLimit(10).continueIfHardObjectivesFulfilled()
-//                                              ))
-//                              .build();
-//
-//              var model = store.createEmptyModel();
-//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
-//
-//              var modelElementInterpretation = model.getInterpretation(classModel);
-//              modelElementInterpretation.put(dseAdapter.createObject(), true);
-//              queryEngine.flushChanges();
-//
-//              var states = dseAdapter.explore();
-//              assertEquals(2047, states.size());
-//      }
-//
-//      @Test
-//      void BeFSSolutionLimitTest() {
-//              var createClassPrecondition = Query.of("CreateClassPrecondition",
-//                              (builder, model) -> builder.clause(
-//                                              classModelView.call(model)
-//                              ));
-//
-//              var createClassRule = new TransformationRule("CreateClass",
-//                              createClassPrecondition,
-//                              (model) -> {
-//                                      var classesInterpretation = model.getInterpretation(classes);
-//                                      var classElementInterpretation = model.getInterpretation(classElement);
-//                                      return ((Tuple activation) -> {
-//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//                                              var modelElement = activation.get(0);
-//
-//                                              var newClassElement = dseAdapter.createObject();
-//                                              var newClassElementId = newClassElement.get(0);
-//
-//                                              classesInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-//                                              classElementInterpretation.put(Tuple.of(newClassElementId), true);
-//                                      });
-//                              });
-//
-//              var createFeaturePrecondition = Query.of("CreateFeaturePrecondition",
-//                              (builder, model) -> builder.clause(
-//                                              classModelView.call(model)
-//                              ));
-//
-//              var createFeatureRule = new TransformationRule("CreateFeature",
-//                              createFeaturePrecondition,
-//                              (model) -> {
-//                                      var featuresInterpretation = model.getInterpretation(features);
-//                                      var featureInterpretation = model.getInterpretation(feature);
-//                                      return ((Tuple activation) -> {
-//                                              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//                                              var modelElement = activation.get(0);
-//
-//                                              var newClassElement = dseAdapter.createObject();
-//                                              var newClassElementId = newClassElement.get(0);
-//
-//                                              featuresInterpretation.put(Tuple.of(modelElement, newClassElementId), true);
-//                                              featureInterpretation.put(Tuple.of(newClassElementId), true);
-//                                      });
-//                              });
-//
-//              var store = ModelStore.builder()
-//                              .symbols(classModel, classElement, classes, feature, features, isEncapsulatedBy, encapsulates)
-//                              .with(ViatraModelQueryAdapter.builder()
-//                                              .queries(createClassPrecondition, createFeaturePrecondition))
-//                              .with(DesignSpaceExplorationAdapter.builder()
-//                                              .transformations(createClassRule, createFeatureRule)
-//                                              .strategy(new BestFirstStrategy().withSolutionLimit(222)
-//                                                              .continueIfHardObjectivesFulfilled()
-//                                              ))
-//                              .build();
-//
-//              var model = store.createEmptyModel();
-//              var dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
-//              var queryEngine = model.getAdapter(ModelQueryAdapter.class);
-//
-//              var modelElementInterpretation = model.getInterpretation(classModel);
-//              modelElementInterpretation.put(dseAdapter.createObject(), true);
-//              queryEngine.flushChanges();
-//
-//              var states = dseAdapter.explore();
-//              assertEquals(222, states.size());
-//      }
-
-}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java
deleted file mode 100644
index 43b04e0d..00000000
--- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/TransformationRuleTest.java
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.dse;
-
-import org.junit.jupiter.api.Test;
-//
-//import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
-//import tools.refinery.store.model.ModelStore;
-//import tools.refinery.store.query.ModelQueryAdapter;
-//import tools.refinery.store.query.dnf.Query;
-//import tools.refinery.store.dse.transition.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.dse.tests.QueryAssertions.assertResults;
-//
-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()
-//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)))
-//                              .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.getAllActivationsAsResultSet();
-//              var deleteEmptyClassRuleActivations = deleteEmptyClassRule.getAllActivationsAsResultSet();
-//
-//              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()
-//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)))
-//                              .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.getAllActivationsAsResultSet());
-//
-//              assertResults(Map.of(
-//                              Tuple.of(newModelId, newClass1Id), true,
-//                              Tuple.of(newModelId, newClass2Id), true
-//              ), deleteEmptyClassRule1.getAllActivationsAsResultSet());
-//
-//              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()
-//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)))
-//                              .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.getAllActivationsAsResultSet());
-//
-//
-//              deleteEmptyClassRule.fireActivation(Tuple.of(0, 1));
-//
-//              assertResults(Map.of(
-//                              Tuple.of(newModelId, newClass1Id), false,
-//                              Tuple.of(newModelId, newClass2Id), true
-//              ), deleteEmptyClassRule.getAllActivationsAsResultSet());
-//      }
-//
-//      @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()
-//                                              .strategy(new DepthFirstStrategy().withDepthLimit(0)))
-//                              .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.getAllActivationsAsResultSet());
-//
-//              deleteEmptyClassRule.fireRandomActivation();
-//
-//              assertResults(Map.of(
-//                              Tuple.of(newModelId, newClass1Id), true,
-//                              Tuple.of(newModelId, newClass2Id), false
-//              ), deleteEmptyClassRule.getAllActivationsAsResultSet());
-//
-//              deleteEmptyClassRule.fireRandomActivation();
-//
-//              assertResults(Map.of(
-//                              Tuple.of(newModelId, newClass1Id), false,
-//                              Tuple.of(newModelId, newClass2Id), false
-//              ), deleteEmptyClassRule.getAllActivationsAsResultSet());
-//
-//      }
-}
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/QueryAssertions.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/QueryAssertions.java
index be514eaf..f0a20720 100644
--- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/QueryAssertions.java
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/tests/QueryAssertions.java
@@ -30,7 +30,7 @@ public final class QueryAssertions {
         }
 
         public static <T> void assertResults(Map<Tuple, T> expected, ResultSet<T> resultSet) {
-                var defaultValue = resultSet.getQuery().defaultValue();
+                var defaultValue = resultSet.getCanonicalQuery().defaultValue();
                 var filteredExpected = new LinkedHashMap<Tuple, T>();
                 var executables = new ArrayList<Executable>();
                 for (var entry : expected.entrySet()) {
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/transition/TransitionTests.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/transition/TransitionTests.java
index b89360cb..42a0f89b 100644
--- a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/transition/TransitionTests.java
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/transition/TransitionTests.java
@@ -7,16 +7,14 @@ package tools.refinery.store.dse.transition;
 
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.dse.modification.ModificationAdapter;
-import tools.refinery.store.dse.transition.objectives.QueryCriteria;
-import tools.refinery.store.dse.transition.objectives.QueryObjective;
+import tools.refinery.store.dse.transition.objectives.Criteria;
+import tools.refinery.store.dse.transition.objectives.Objectives;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.ModelQueryAdapter;
 import tools.refinery.store.query.dnf.FunctionalQuery;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.dnf.RelationalQuery;
-import tools.refinery.store.query.literal.CallPolarity;
-import tools.refinery.store.query.literal.Literals;
 import tools.refinery.store.query.term.Variable;
 import tools.refinery.store.query.term.int_.IntTerms;
 import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
@@ -29,33 +27,33 @@ import tools.refinery.store.tuple.Tuple;
 import java.util.List;
 
 import static org.junit.jupiter.api.Assertions.*;
+import static tools.refinery.store.query.literal.Literals.check;
+import static tools.refinery.store.query.literal.Literals.not;
 
 class TransitionBuildTests {
         Symbol<Boolean> person = new Symbol<>("Person", 1, Boolean.class, false);
         Symbol<Boolean> friend = new Symbol<>("friend", 2, Boolean.class, false);
+
         AnySymbolView personView = new KeyOnlyView<>(person);
         AnySymbolView friendView = new KeyOnlyView<>(friend);
 
-        /*RelationalQuery areNotFriends = Query.of("areNotFriends",
-                        (builder, p1, p2) -> builder.clause(
-                                        personView.call(p1),
-                                        personView.call(p2),
-                                        not(friendView.call(p1, p2))))*/
-
-        RelationalQuery moreThan3Friends = Query.of("moreThan3Friends",
-                        (builder, tooMuchFriends) -> builder.clause(Integer.class, (numberOfFriends) -> List.of(
+        RelationalQuery moreThan3Friends = Query.of("moreThan3Friends", (builder, tooMuchFriends) -> builder
+                        .clause(Integer.class, (numberOfFriends) -> List.of(
                                         numberOfFriends.assign(friendView.count(tooMuchFriends, Variable.of())),
-                                        Literals.assume(IntTerms.less(IntTerms.constant(3), numberOfFriends)),
+                                        check(IntTerms.less(IntTerms.constant(3), numberOfFriends)),
                                         personView.call(tooMuchFriends)
                         )));
 
-        RelationalQuery somebodyHasNoFriend = Query.of("somebodyHasNoFriend",
-                        (builder, lonely) -> builder.clause(
+        RelationalQuery somebodyHasNoFriend = Query.of("somebodyHasNoFriend", (builder, lonely) -> builder
+                        .clause(
                                         personView.call(lonely),
-                                        friendView.call(CallPolarity.NEGATIVE, lonely, Variable.of())
+                                        not(friendView.call(lonely, Variable.of()))
+                        ));
+
+        FunctionalQuery<Integer> numberOfFriends = Query.of(Integer.class, (builder, output) -> builder
+                        .clause(
+                                        output.assign(friendView.count(Variable.of(), Variable.of()))
                         ));
-        FunctionalQuery<Integer> numberOfFriends = FunctionalQuery.of(Integer.class,
-                        (builder, output) -> builder.clause(output.assign(friendView.count(Variable.of(), Variable.of()))));
 
         @Test
         void acceptTest() {
@@ -141,9 +139,9 @@ class TransitionBuildTests {
                                 .with(StateCoderAdapter.builder())
                                 .with(ModificationAdapter.builder())
                                 .with(DesignSpaceExplorationAdapter.builder()
-                                                .objective(new QueryObjective(numberOfFriends))
-                                                .exclude(new QueryCriteria(moreThan3Friends, true))
-                                                .accept(new QueryCriteria(somebodyHasNoFriend, false)))
+                                                .objective(Objectives.value(numberOfFriends))
+                                                .exclude(Criteria.whenHasMatch(moreThan3Friends))
+                                                .accept(Criteria.whenNoMatch(somebodyHasNoFriend)))
                                 .build();
 
                 return store.createEmptyModel();