Merge pull request #38 from nagilooh/design-space-exploration

Comparable transformation rule action

13 files changed, 1037 insertions, 0 deletions

diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java
index 5aed5298..ab87ddd5 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/DesignSpaceExplorationAdapter.java
@@ -6,6 +6,7 @@
 package tools.refinery.store.dse;
 
 import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.dse.internal.TransformationRule;
 import tools.refinery.store.map.Version;
 import tools.refinery.store.dse.internal.Activation;
 import tools.refinery.store.dse.internal.DesignSpaceExplorationBuilderImpl;
@@ -65,4 +66,6 @@ public interface DesignSpaceExplorationAdapter extends ModelAdapter {
         public void setRandom(long seed);
 
         public List<Version> getSolutions();
+
+        void addTransformationRule(TransformationRule transformationRule);
 }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java
index 220f0b2d..1ae09916 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/DesignSpaceExplorationAdapterImpl.java
@@ -13,6 +13,7 @@ import tools.refinery.store.map.Version;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.dnf.RelationalQuery;
 import tools.refinery.store.dse.DesignSpaceExplorationAdapter;
 import tools.refinery.store.dse.DesignSpaceExplorationStoreAdapter;
@@ -45,6 +46,7 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
         private Map<Version, Version> parents = new HashMap<>();
         private final List<Version> solutions = new ArrayList<>();
         private Map<Version, List<Activation>> statesAndTraversedActivations;
+        @SuppressWarnings("squid:S2245")
         private Random random = new Random();
         private boolean isNewState = false;
         private final boolean isVisualizationEnabled;
@@ -77,6 +79,12 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
 
         }
 
+        @Override
+        public void addTransformationRule(TransformationRule rule) {
+                transformationRules.add(rule);
+                rule.prepare(model, queryEngine);
+        }
+
         public List<Version> getTrajectory() {
                 return new ArrayList<>(trajectory);
         }
@@ -175,6 +183,7 @@ public class DesignSpaceExplorationAdapterImpl implements DesignSpaceExploration
         }
 
         @Override
+        @SuppressWarnings("squid:S2245")
         public void setRandom(long seed) {
                 this.random = new Random(seed);
         }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java
index 8123c0d6..37117164 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/TransformationRule.java
@@ -26,10 +26,12 @@ public class TransformationRule {
         private Random random;
         private ModelQueryAdapter queryEngine;
 
+        @SuppressWarnings("squid:S2245")
         public TransformationRule(String name, RelationalQuery precondition, ActionFactory actionFactory) {
                 this(name, precondition, actionFactory, new Random());
         }
 
+        @SuppressWarnings("squid:S2245")
         public TransformationRule(String name, RelationalQuery precondition, ActionFactory actionFactory, long seed) {
                 this(name, precondition, actionFactory, new Random(seed));
         }
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActionVariable.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActionVariable.java
new file mode 100644
index 00000000..92de565d
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActionVariable.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.tuple.Tuple;
+
+public interface ActionVariable extends AtomicAction {
+        Tuple getValue();
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActivationVariable.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActivationVariable.java
new file mode 100644
index 00000000..6b4c6340
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/ActivationVariable.java
@@ -0,0 +1,54 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+
+public class ActivationVariable implements ActionVariable {
+
+        private final int index;
+        private Tuple value;
+
+        public ActivationVariable() {
+                this(0);
+        }
+
+        public ActivationVariable(int index) {
+                this.index = index;
+        }
+
+        @Override
+        public void fire(Tuple activation) {
+                value = Tuple.of(activation.get(index));
+        }
+
+        @Override
+        public ActivationVariable prepare(Model model) {
+                return this;
+        }
+
+        @Override
+        public Tuple getValue() {
+                return value;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(AtomicAction other) {
+                if (other == null || getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherAction = (ActivationVariable) other;
+
+                if (index != otherAction.index) {
+                        return false;
+                }
+                if (value == null) {
+                        return otherAction.value == null;
+                }
+                return value.equals(otherAction.value);
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/AtomicAction.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/AtomicAction.java
new file mode 100644
index 00000000..a8f10bca
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/AtomicAction.java
@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+
+public interface AtomicAction {
+
+        void fire(Tuple activation);
+
+        AtomicAction prepare(Model model);
+
+        boolean equalsWithSubstitution(AtomicAction other);
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/DeleteAction.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/DeleteAction.java
new file mode 100644
index 00000000..9900390f
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/DeleteAction.java
@@ -0,0 +1,40 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.dse.DesignSpaceExplorationAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+
+public class DeleteAction implements AtomicAction {
+
+        private final ActionVariable variable;
+        private DesignSpaceExplorationAdapter dseAdapter;
+
+        public DeleteAction(ActionVariable variable) {
+                this.variable = variable;
+        }
+
+        @Override
+        public void fire(Tuple activation) {
+                dseAdapter.deleteObject(variable.getValue());
+        }
+
+        @Override
+        public DeleteAction prepare(Model model) {
+                dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                return this;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(AtomicAction other) {
+                if (other == null || getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherAction = (DeleteAction) other;
+                return this.variable.getClass() == otherAction.variable.getClass();
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/InsertAction.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/InsertAction.java
new file mode 100644
index 00000000..90fcc5ac
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/InsertAction.java
@@ -0,0 +1,94 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple0;
+
+import java.util.Arrays;
+
+public class InsertAction<T> implements AtomicAction {
+
+        private final Interpretation<T> interpretation;
+        private final T value;
+        private final int arity;
+        private final ActionVariable[] variables;
+
+        public InsertAction(Interpretation<T> interpretation, T value, ActionVariable... variables) {
+                this.interpretation = interpretation;
+                this.value = value;
+                this.variables = variables;
+                this.arity = interpretation.getSymbol().arity();
+                if (variables.length != arity) {
+                        throw new IllegalArgumentException("Expected " + arity + " variables, but got " + variables.length);
+                }
+        }
+
+        @Override
+        public void fire(Tuple activation) {
+                Tuple tuple;
+                if (arity == 0) {
+                        tuple = Tuple0.INSTANCE;
+                }
+                else if (arity == 1) {
+                        tuple = variables[0].getValue();
+                }
+                else if (arity == 2) {
+                        tuple = Tuple.of(variables[0].getValue().get(0), variables[1].getValue().get(0));
+                }
+                else if (arity == 3) {
+                        tuple = Tuple.of(variables[0].getValue().get(0), variables[1].getValue().get(0), variables[2].getValue().get(0));
+                }
+                else {
+                        tuple = Tuple.of(Arrays.stream(variables).map(variable -> variable.getValue().get(0))
+                                        .mapToInt(Integer::intValue).toArray());
+                }
+                interpretation.put(tuple, value);
+        }
+
+        public void put(Tuple tuple) {
+                interpretation.put(tuple, value);
+        }
+
+        @Override
+        public InsertAction<T> prepare(Model model) {
+                return this;
+        }
+
+        public ActionVariable[] getVariables() {
+                return variables;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(AtomicAction other) {
+                if (other == null || getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherAction = (InsertAction<?>) other;
+                if (variables.length != otherAction.variables.length) {
+                        return false;
+                }
+                if (!interpretation.equals(otherAction.interpretation)) {
+                        return false;
+                }
+                if (value == null) {
+                        if (otherAction.value != null) {
+                                return false;
+                        }
+                }
+        else if (!value.equals(otherAction.value)) {
+                        return false;
+                }
+                for (var i = 0; i < variables.length; i++) {
+                        if (!variables[i].equalsWithSubstitution(otherAction.variables[i])) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/NewItemVariable.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/NewItemVariable.java
new file mode 100644
index 00000000..cbb9697e
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/NewItemVariable.java
@@ -0,0 +1,45 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.dse.DesignSpaceExplorationAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple1;
+
+public class NewItemVariable implements ActionVariable {
+        private DesignSpaceExplorationAdapter dseAdapter;
+        private Tuple1 value;
+
+        @Override
+        public void fire(Tuple activation) {
+                value = dseAdapter.createObject();
+        }
+
+        @Override
+        public NewItemVariable prepare(Model model) {
+                dseAdapter = model.getAdapter(DesignSpaceExplorationAdapter.class);
+                return this;
+        }
+
+        @Override
+        public Tuple1 getValue() {
+                return value;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(AtomicAction other) {
+                if (other == null || getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherAction = (NewItemVariable) other;
+                if (value == null) {
+                        return otherAction.value == null;
+                }
+                return value.equals(otherAction.value);
+
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/TransformationAction.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/TransformationAction.java
new file mode 100644
index 00000000..adc4df9e
--- /dev/null
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/internal/action/TransformationAction.java
@@ -0,0 +1,129 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse.internal.action;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple2;
+
+import java.util.*;
+
+public class TransformationAction {
+        private final List<ActionVariable> actionVariables = new ArrayList<>();
+        private final List<InsertAction<?>> insertActions = new ArrayList<>();
+        private final List<DeleteAction> deleteActions = new ArrayList<>();
+        private boolean configured = false;
+        private final Map<Integer, List<Tuple2>> actionVariableUsageMap = new LinkedHashMap<>();
+
+        public TransformationAction add(ActionVariable action) {
+                checkConfigured();
+                actionVariables.add(action);
+                return this;
+        }
+
+        public TransformationAction add(InsertAction<?> action) {
+                checkConfigured();
+                insertActions.add(action);
+                return this;
+        }
+
+        public TransformationAction add(DeleteAction action) {
+                checkConfigured();
+                deleteActions.add(action);
+                return this;
+        }
+
+        private void checkConfigured() {
+                if (configured) {
+                        throw new IllegalStateException("Action already configured.");
+                }
+        }
+
+        public TransformationAction prepare(Model model) {
+                for (ActionVariable action : actionVariables) {
+                        action.prepare(model);
+                }
+                for (InsertAction<?> action : insertActions) {
+                        action.prepare(model);
+                }
+                for (DeleteAction action : deleteActions) {
+                        action.prepare(model);
+                }
+
+                for (var insertAction : insertActions) {
+                        var actionIndex = insertActions.indexOf(insertAction);
+                        var variables = insertAction.getVariables();
+                        for (var i = 0; i < variables.length; i++) {
+                                var variablelGlobalIndex = actionVariables.indexOf(variables[i]);
+                                actionVariableUsageMap.computeIfAbsent(variablelGlobalIndex, k -> new ArrayList<>());
+                                actionVariableUsageMap.get(variablelGlobalIndex).add(Tuple.of(actionIndex, i));
+                        }
+                }
+
+                configured = true;
+                return this;
+        }
+
+        public boolean fire(Tuple activation) {
+                for (ActionVariable action : actionVariables) {
+                        action.fire(activation);
+                }
+                for (InsertAction<?> action : insertActions) {
+                        action.fire(activation);
+                }
+                for (DeleteAction action : deleteActions) {
+                        action.fire(activation);
+                }
+                return true;
+        }
+
+        // Returns true if ActionVariables and InsertActions are inserted in same order, ActionVariables are equal (they
+        // have the same index for getting the value from the activation Tuple) and InsertActions are equal (they have
+        // the same arity and value to be set).
+        public boolean equalsWithSubstitution(TransformationAction other) {
+                if (other == this) {
+                        return true;
+                }
+
+                if (actionVariables.size() != other.actionVariables.size()) {
+                        return false;
+                }
+
+                if (insertActions.size() != other.insertActions.size()) {
+                        return false;
+                }
+
+                if (deleteActions.size() != other.deleteActions.size()) {
+                        return false;
+                }
+
+                for (var i = 0; i < actionVariables.size(); i++) {
+                        var variable = actionVariables.get(i);
+                        var otherVariable = other.actionVariables.get(i);
+                        if (!variable.equalsWithSubstitution(otherVariable)) {
+                                return false;
+                        }
+                }
+
+                for (var i = 0; i < insertActions.size(); i++) {
+                        var insertAction = insertActions.get(i);
+                        var otherInsertAction = other.insertActions.get(i);
+                        if (!insertAction.equalsWithSubstitution(otherInsertAction)) {
+                                return false;
+                        }
+                }
+
+                for (var i = 0; i < deleteActions.size(); i++) {
+                        var deleteAction = deleteActions.get(i);
+                        var otherDeleteAction = other.deleteActions.get(i);
+                        if (!deleteAction.equalsWithSubstitution(otherDeleteAction)) {
+                                return false;
+                        }
+                }
+                return this.actionVariableUsageMap.equals(other.actionVariableUsageMap);
+
+        }
+}
diff --git a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/objectives/AlwaysSatisfiedRandomHardObjective.java b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/objectives/AlwaysSatisfiedRandomHardObjective.java
index 327d5e2f..cdd1754f 100644
--- a/subprojects/store-dse/src/main/java/tools/refinery/store/dse/objectives/AlwaysSatisfiedRandomHardObjective.java
+++ b/subprojects/store-dse/src/main/java/tools/refinery/store/dse/objectives/AlwaysSatisfiedRandomHardObjective.java
@@ -22,6 +22,7 @@ import java.util.Random;
 public class AlwaysSatisfiedRandomHardObjective extends BaseObjective {
 
         private static final String DEFAULT_NAME = "AlwaysSatisfiedDummyHardObjective";
+        @SuppressWarnings("squid:S2245")
         private static final Random random = new Random(0);
 
         public AlwaysSatisfiedRandomHardObjective() {
diff --git a/subprojects/store-dse/src/test/java/tools/refinery/store/dse/ActionEqualsTest.java b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/ActionEqualsTest.java
new file mode 100644
index 00000000..d4a05d12
--- /dev/null
+++ b/subprojects/store-dse/src/test/java/tools/refinery/store/dse/ActionEqualsTest.java
@@ -0,0 +1,629 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.dse;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.dse.internal.action.*;
+import tools.refinery.store.dse.strategy.DepthFirstStrategy;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
+import tools.refinery.store.query.view.KeyOnlyView;
+import tools.refinery.store.representation.Symbol;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class ActionEqualsTest {
+
+        private static Model model;
+        private static Symbol<Boolean> type1;
+        private static Symbol<Boolean> relation1;
+        private static Symbol<Boolean> relation2;
+
+        @BeforeAll
+        public static void init() {
+                type1 = Symbol.of("type1", 1);
+                relation1 = Symbol.of("relation1", 2);
+                relation2 = Symbol.of("relation2", 2);
+                var type1View = new KeyOnlyView<>(type1);
+                var precondition1 = Query.of("CreateClassPrecondition",
+                                (builder, model) -> builder.clause(
+                                                type1View.call(model)
+                                ));
+
+                var precondition2 = Query.of("CreateFeaturePrecondition",
+                                (builder, model) -> builder.clause(
+                                                type1View.call(model)
+                                ));
+                var store = ModelStore.builder()
+                                .symbols(type1, relation2, relation1)
+                                .with(ViatraModelQueryAdapter.builder()
+                                                .queries(precondition1, precondition2))
+                                .with(DesignSpaceExplorationAdapter.builder()
+                                                .strategy(new DepthFirstStrategy()))
+                                .build();
+
+
+                model = store.createEmptyModel();
+        }
+
+        @Test
+        void emptyActionEqualsTest() {
+                var action1 = new TransformationAction();
+                var action2 = new TransformationAction();
+
+                assertTrue(action1.equalsWithSubstitution(action1));
+                assertTrue(action2.equalsWithSubstitution(action2));
+                assertTrue(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void actionTrivialTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var activationSymbol = new ActivationVariable();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol);
+                var insertAction3 = new InsertAction<>(model.getInterpretation(type1), true, newItemSymbol1);
+                var insertAction4 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol);
+                action1.add(insertAction1);
+                action1.add(insertAction2);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol);
+                action2.add(insertAction3);
+                action2.add(insertAction4);
+                action2.prepare(model);
+
+                assertTrue(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void actionIdenticalTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var activationSymbol1 = new ActivationVariable();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var newItemSymbol2 = new NewItemVariable();
+                var activationSymbol2 = new ActivationVariable();
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol2,
+                                activationSymbol2);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol2);
+                action2.add(activationSymbol2);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertTrue(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void actionSymbolGlobalOrderTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var activationSymbol1 = new ActivationVariable();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var newItemSymbol2 = new NewItemVariable();
+                var activationSymbol2 = new ActivationVariable();
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol2,
+                                activationSymbol2);
+
+                var action2 = new TransformationAction();
+                action2.add(activationSymbol2);
+                action2.add(newItemSymbol2);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertFalse(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void actionSymbolRepeatedInInsertActionTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                newItemSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var newItemSymbol2 = new NewItemVariable();
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol2,
+                                newItemSymbol2);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol2);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertTrue(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void identicalInsertActionInDifferentOrderTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var activationSymbol1 = new ActivationVariable();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.add(insertAction2);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.add(insertAction1);
+                action2.prepare(model);
+
+                assertTrue(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void identicalActionAndSymbolDifferentOrderTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var newItemSymbol2 = new NewItemVariable();
+                var activationSymbol1 = new ActivationVariable();
+                var activationSymbol2 = new ActivationVariable();
+
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol2,
+                                activationSymbol2);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(newItemSymbol2);
+                action1.add(activationSymbol1);
+                action1.add(activationSymbol2);
+                action1.add(insertAction1);
+                action1.add(insertAction2);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol2);
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol2);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.add(insertAction1);
+                action2.prepare(model);
+
+                assertTrue(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void identicalActionAndSymbolMixedOrderTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var activationSymbol1 = new ActivationVariable();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+
+                var newItemSymbol2 = new NewItemVariable();
+                var activationSymbol2 = new ActivationVariable();
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol2,
+                                activationSymbol2);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(newItemSymbol2);
+                action1.add(activationSymbol1);
+                action1.add(activationSymbol2);
+                action1.add(insertAction1);
+                action1.add(insertAction2);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(insertAction1);
+                action2.add(newItemSymbol1);
+                action2.add(newItemSymbol2);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.add(activationSymbol2);
+                action2.prepare(model);
+
+                assertTrue(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void insertActionInterpretationTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var activationSymbol1 = new ActivationVariable();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation2), true, newItemSymbol1,
+                                activationSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertFalse(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void insertActionValueTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var activationSymbol1 = new ActivationVariable();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), false, newItemSymbol1,
+                                activationSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertFalse(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void newItemSymbolDuplicateTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var newItemSymbol2 = new NewItemVariable();
+                var activationSymbol1 = new ActivationVariable();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol2,
+                                activationSymbol1);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol2);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertTrue(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void activationSymbolDuplicateTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var activationSymbol1 = new ActivationVariable();
+                var activationSymbol2 = new ActivationVariable();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol2);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol2);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertTrue(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void activationSymbolIndexTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var activationSymbol1 = new ActivationVariable(0);
+                var activationSymbol2 = new ActivationVariable(1);
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol2);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(activationSymbol1);
+                action1.add(insertAction1);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol1);
+                action2.add(activationSymbol2);
+                action2.add(insertAction2);
+                action2.prepare(model);
+
+                assertFalse(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void deleteActionTest() {
+                var newItemSymbol = new NewItemVariable();
+                var activationSymbol = new ActivationVariable(0);
+                var insertAction = new InsertAction<>(model.getInterpretation(relation1), false, newItemSymbol,
+                                activationSymbol);
+                var deleteAction = new DeleteAction(activationSymbol);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol);
+                action1.add(activationSymbol);
+                action1.add(insertAction);
+                action1.add(deleteAction);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol);
+                action2.add(activationSymbol);
+                action2.add(insertAction);
+                action2.add(deleteAction);
+                action2.prepare(model);
+
+                assertTrue(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void deleteActionMissingTest() {
+                var newItemSymbol = new NewItemVariable();
+                var activationSymbol = new ActivationVariable(0);
+                var insertAction = new InsertAction<>(model.getInterpretation(relation1), false, newItemSymbol,
+                                activationSymbol);
+                var deleteAction = new DeleteAction(activationSymbol);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol);
+                action1.add(activationSymbol);
+                action1.add(insertAction);
+                action1.add(deleteAction);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol);
+                action2.add(activationSymbol);
+                action2.add(insertAction);
+                action2.prepare(model);
+
+                assertFalse(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void deleteActionIdenticalTest() {
+                var newItemSymbol = new NewItemVariable();
+                var activationSymbol = new ActivationVariable(0);
+                var insertAction = new InsertAction<>(model.getInterpretation(relation1), false, newItemSymbol,
+                                activationSymbol);
+                var deleteAction1 = new DeleteAction(activationSymbol);
+                var deleteAction2 = new DeleteAction(activationSymbol);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol);
+                action1.add(activationSymbol);
+                action1.add(insertAction);
+                action1.add(deleteAction1);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol);
+                action2.add(activationSymbol);
+                action2.add(insertAction);
+                action2.add(deleteAction2);
+                action2.prepare(model);
+
+                assertTrue(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void deleteActionSymbolTypeTest() {
+                var newItemSymbol = new NewItemVariable();
+                var activationSymbol = new ActivationVariable(0);
+                var insertAction = new InsertAction<>(model.getInterpretation(relation1), false, newItemSymbol,
+                                activationSymbol);
+                var deleteAction1 = new DeleteAction(activationSymbol);
+                var deleteAction2 = new DeleteAction(newItemSymbol);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol);
+                action1.add(activationSymbol);
+                action1.add(insertAction);
+                action1.add(deleteAction1);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol);
+                action2.add(activationSymbol);
+                action2.add(insertAction);
+                action2.add(deleteAction2);
+                action2.prepare(model);
+
+                assertFalse(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void deleteActionOrderTest() {
+                var newItemSymbol = new NewItemVariable();
+                var activationSymbol = new ActivationVariable(0);
+                var insertAction = new InsertAction<>(model.getInterpretation(relation1), false, newItemSymbol,
+                                activationSymbol);
+                var deleteAction1 = new DeleteAction(activationSymbol);
+                var deleteAction2 = new DeleteAction(newItemSymbol);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol);
+                action1.add(activationSymbol);
+                action1.add(insertAction);
+                action1.add(deleteAction1);
+                action1.add(deleteAction2);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(newItemSymbol);
+                action2.add(activationSymbol);
+                action2.add(insertAction);
+                action2.add(deleteAction2);
+                action2.add(deleteAction1);
+                action2.prepare(model);
+
+                assertFalse(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void actionsMixedOrderTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var activationSymbol1 = new ActivationVariable();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+                var deleteAction1 = new DeleteAction(newItemSymbol1);
+
+                var newItemSymbol2 = new NewItemVariable();
+                var activationSymbol2 = new ActivationVariable();
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol2,
+                                activationSymbol2);
+                var deleteAction2 = new DeleteAction(activationSymbol2);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(newItemSymbol2);
+                action1.add(activationSymbol1);
+                action1.add(activationSymbol2);
+                action1.add(insertAction1);
+                action1.add(insertAction2);
+                action1.add(deleteAction1);
+                action1.add(deleteAction2);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(deleteAction1);
+                action2.add(newItemSymbol1);
+                action2.add(insertAction1);
+                action2.add(newItemSymbol2);
+                action2.add(deleteAction2);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.add(activationSymbol2);
+                action2.prepare(model);
+
+                assertTrue(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void twoUnpreparedActionsTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var activationSymbol1 = new ActivationVariable();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+                var deleteAction1 = new DeleteAction(newItemSymbol1);
+
+                var newItemSymbol2 = new NewItemVariable();
+                var activationSymbol2 = new ActivationVariable();
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol2,
+                                activationSymbol2);
+                var deleteAction2 = new DeleteAction(activationSymbol2);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(newItemSymbol2);
+                action1.add(activationSymbol1);
+                action1.add(activationSymbol2);
+                action1.add(insertAction1);
+                action1.add(insertAction2);
+                action1.add(deleteAction1);
+                action1.add(deleteAction2);
+
+                var action2 = new TransformationAction();
+                action2.add(deleteAction1);
+                action2.add(newItemSymbol1);
+                action2.add(insertAction1);
+                action2.add(newItemSymbol2);
+                action2.add(deleteAction2);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.add(activationSymbol2);
+
+                assertTrue(action1.equalsWithSubstitution(action2));
+        }
+
+        @Test
+        void oneUnpreparedActionTest() {
+                var newItemSymbol1 = new NewItemVariable();
+                var activationSymbol1 = new ActivationVariable();
+                var insertAction1 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol1,
+                                activationSymbol1);
+                var deleteAction1 = new DeleteAction(newItemSymbol1);
+
+                var newItemSymbol2 = new NewItemVariable();
+                var activationSymbol2 = new ActivationVariable();
+                var insertAction2 = new InsertAction<>(model.getInterpretation(relation1), true, newItemSymbol2,
+                                activationSymbol2);
+                var deleteAction2 = new DeleteAction(activationSymbol2);
+
+                var action1 = new TransformationAction();
+                action1.add(newItemSymbol1);
+                action1.add(newItemSymbol2);
+                action1.add(activationSymbol1);
+                action1.add(activationSymbol2);
+                action1.add(insertAction1);
+                action1.add(insertAction2);
+                action1.add(deleteAction1);
+                action1.add(deleteAction2);
+                action1.prepare(model);
+
+                var action2 = new TransformationAction();
+                action2.add(deleteAction1);
+                action2.add(newItemSymbol1);
+                action2.add(insertAction1);
+                action2.add(newItemSymbol2);
+                action2.add(deleteAction2);
+                action2.add(activationSymbol1);
+                action2.add(insertAction2);
+                action2.add(activationSymbol2);
+
+                assertFalse(action1.equalsWithSubstitution(action2));
+        }
+}
diff --git a/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/ModelVisualizerAdapterImpl.java b/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/ModelVisualizerAdapterImpl.java
index 531969b4..e60ae4b7 100644
--- a/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/ModelVisualizerAdapterImpl.java
+++ b/subprojects/visualization/src/main/java/tools/refinery/visualization/internal/ModelVisualizerAdapterImpl.java
@@ -220,6 +220,7 @@ public class ModelVisualizerAdapterImpl implements ModelVisualizerAdapter {
         }
 
         private Integer[] typeColor(String name) {
+                @SuppressWarnings("squid:S2245")
                 var random = new Random(name.hashCode());
                 return new Integer[] { random.nextInt(128) + 128, random.nextInt(128) + 128, random.nextInt(128) + 128 };
         }