Intermediate commit with Lazy NeighbourhoodCalculator and StateEquivalenceChecker prototypes

2 files changed, 187 insertions, 0 deletions

diff --git a/subprojects/store/src/test/java/tools/refinery/store/statecoding/ExperimentalSetupTest.java b/subprojects/store/src/test/java/tools/refinery/store/statecoding/ExperimentalSetupTest.java
new file mode 100644
index 00000000..87b1623c
--- /dev/null
+++ b/subprojects/store/src/test/java/tools/refinery/store/statecoding/ExperimentalSetupTest.java
@@ -0,0 +1,107 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.map.Version;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.*;
+
+class ExperimentalSetupTest {
+        public static void generate(int size) {
+                Symbol<Boolean> person = new Symbol<>("Person", 1, Boolean.class, false);
+                Symbol<Boolean> friend = new Symbol<>("friend", 2, Boolean.class, false);
+
+                var store = ModelStore.builder()
+                                .symbols(person, friend)
+                                .with(StateCoderAdapter
+                                                .builder())
+                                .build();
+
+                Set<Version> versions = new HashSet<>();
+                Map<Integer, List<Version>> codes = new HashMap<>();
+
+                var empty = store.createEmptyModel();
+                var pI = empty.getInterpretation(person);
+
+                for (int i = 0; i < size; i++) {
+                        pI.put(Tuple.of(i), true);
+                }
+
+                var emptyVersion = empty.commit();
+                versions.add(emptyVersion);
+                var emptyCode = empty.getAdapter(StateCoderAdapter.class).calculateModelCode();
+                List<Version> emptyList = new ArrayList<>();
+                emptyList.add(emptyVersion);
+                codes.put(emptyCode, emptyList);
+
+                var storeAdapter = store.getAdapter(StateCoderStoreAdapter.class);
+
+                int dif = 0;
+                int iso = 0;
+                int unk = 0;
+
+                //int step = 0
+
+                for (int i = 0; i < size; i++) {
+                        for (int j = 0; j < size; j++) {
+                                var previousVersions = new HashSet<>(versions);
+                                for (var version : previousVersions) {
+
+                                        var model = store.createModelForState(version);
+                                        model.getInterpretation(friend).put(Tuple.of(i, j), true);
+
+                                        Version version1 = model.commit();
+                                        var stateCode = model.getAdapter(StateCoderAdapter.class).calculateStateCode();
+                                        int code = stateCode.modelCode();
+                                        //System.out.println(step+++" ->" +code);
+                                        if (codes.containsKey(code)) {
+                                                Version similar = codes.get(code).get(0);
+
+                                                var outcome = storeAdapter.checkEquivalence(version1, similar);
+                                                if (outcome == StateEquivalenceChecker.EquivalenceResult.DIFFERENT) {
+                                                        System.out.println();
+                                                        var c = model.getInterpretation(friend).getAll();
+                                                        while (c.move()) {
+                                                                System.out.println(c.getKey().toString());
+                                                        }
+                                                        System.out.println("vs");
+                                                        var c2 = store.createModelForState(similar).getInterpretation(friend).getAll();
+                                                        while (c2.move()) {
+                                                                System.out.println(c2.getKey().toString());
+                                                        }
+
+                                                        dif++;
+                                                } else if (outcome == StateEquivalenceChecker.EquivalenceResult.UNKNOWN) {
+                                                        unk++;
+                                                } else {
+                                                        iso++;
+                                                }
+                                        } else {
+                                                versions.add(version1);
+
+                                                List<Version> newList = new ArrayList<>();
+                                                newList.add(version1);
+                                                codes.put(code, newList);
+                                        }
+                                }
+                        }
+                }
+
+                System.out.printf("v=%d i=%d d=%d u=%d\n", versions.size(), iso, dif, unk);
+        }
+
+        @Test
+        void runTests() {
+                for (int i = 0; i < 5; i++) {
+                        System.out.println("size = " + i);
+                        generate(i);
+                }
+        }
+}
diff --git a/subprojects/store/src/test/java/tools/refinery/store/statecoding/StateCoderBuildTest.java b/subprojects/store/src/test/java/tools/refinery/store/statecoding/StateCoderBuildTest.java
new file mode 100644
index 00000000..b0b80af7
--- /dev/null
+++ b/subprojects/store/src/test/java/tools/refinery/store/statecoding/StateCoderBuildTest.java
@@ -0,0 +1,80 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.statecoding;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class StateCoderBuildTest {
+        Symbol<Boolean> person = new Symbol<>("Person", 1, Boolean.class, false);
+        Symbol<Integer> age = new Symbol<>("age", 1, Integer.class, null);
+        Symbol<Boolean> friend = new Symbol<>("friend", 2, Boolean.class, false);
+
+        @Test
+        void simpleStateCoderTest() {
+                var store = ModelStore.builder()
+                                .symbols(person, age, friend)
+                                .with(StateCoderAdapter
+                                                .builder())
+                                .build();
+
+                var model = store.createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+                assertNotNull(stateCoder);
+
+                var personI = model.getInterpretation(person);
+                var friendI = model.getInterpretation(friend);
+                var ageI = model.getInterpretation(age);
+                fill(personI, friendI, ageI);
+
+                stateCoder.calculateStateCode();
+        }
+
+        @Test
+        void excludeTest() {
+                var store = ModelStore.builder()
+                                .symbols(person, age, friend)
+                                .with(StateCoderAdapter.builder()
+                                                .exclude(person)
+                                                .exclude(age))
+                                .build();
+
+                var model = store.createEmptyModel();
+                var stateCoder = model.getAdapter(StateCoderAdapter.class);
+                assertNotNull(stateCoder);
+
+                var personI = model.getInterpretation(person);
+                var friendI = model.getInterpretation(friend);
+                var ageI = model.getInterpretation(age);
+                fill(personI, friendI, ageI);
+
+                int code = stateCoder.calculateStateCode().modelCode();
+
+                ageI.put(Tuple.of(1),3);
+                assertEquals(code,stateCoder.calculateStateCode().modelCode());
+
+                ageI.put(Tuple.of(1),null);
+                assertEquals(code,stateCoder.calculateStateCode().modelCode());
+
+                personI.put(Tuple.of(2),false);
+                assertEquals(code,stateCoder.calculateStateCode().modelCode());
+        }
+
+        private static void fill(Interpretation<Boolean> personI, Interpretation<Boolean> friendI, Interpretation<Integer> ageI) {
+                personI.put(Tuple.of(1), true);
+                personI.put(Tuple.of(2), true);
+
+                ageI.put(Tuple.of(1), 5);
+                ageI.put(Tuple.of(2), 4);
+
+                friendI.put(Tuple.of(1, 2), true);
+        }
+}