49 files changed, 1349 insertions, 168 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