fix: nullary model initialization

Decision trees can only handle relations with 1 level and up, so we use a
special case for nullary relations.

5 files changed, 129 insertions, 13 deletions

diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
index 12bb94c2..5f854ac3 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
@@ -9,7 +9,7 @@ import com.google.inject.Inject;
 import org.eclipse.collections.api.factory.primitive.ObjectIntMaps;
 import org.eclipse.collections.api.map.primitive.MutableObjectIntMap;
 import tools.refinery.language.model.problem.*;
-import tools.refinery.language.semantics.model.internal.DecisionTree;
+import tools.refinery.language.semantics.model.internal.MutableSeed;
 import tools.refinery.language.utils.BuiltinSymbols;
 import tools.refinery.language.utils.ProblemDesugarer;
 import tools.refinery.language.utils.ProblemUtil;
@@ -306,7 +306,7 @@ public class ModelInitializer {
         }
 
         private void collectEnumAssertions(EnumDeclaration enumDeclaration) {
-                var overlay = new DecisionTree(1, null);
+                var overlay = MutableSeed.of(1, null);
                 for (var literal : enumDeclaration.getLiterals()) {
                         collectIndividualAssertions(literal);
                         var nodeId = getNodeId(literal);
@@ -535,15 +535,15 @@ public class ModelInitializer {
                 return argumentList;
         }
 
-        private record RelationInfo(PartialRelation partialRelation, DecisionTree assertions,
-                                                                DecisionTree defaultAssertions) {
+        private record RelationInfo(PartialRelation partialRelation, MutableSeed<TruthValue> assertions,
+                                                                MutableSeed<TruthValue> defaultAssertions) {
                 public RelationInfo(String name, int arity, TruthValue value, TruthValue defaultValue) {
                         this(new PartialRelation(name, arity), value, defaultValue);
                 }
 
                 public RelationInfo(PartialRelation partialRelation, TruthValue value, TruthValue defaultValue) {
-                        this(partialRelation, new DecisionTree(partialRelation.arity(), value),
-                                        new DecisionTree(partialRelation.arity(), defaultValue));
+                        this(partialRelation, MutableSeed.of(partialRelation.arity(), value),
+                                        MutableSeed.of(partialRelation.arity(), defaultValue));
                 }
 
                 public Seed<TruthValue> toSeed(int nodeCount) {
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/DecisionTree.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/DecisionTree.java
index d693dec3..c5479859 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/DecisionTree.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/DecisionTree.java
@@ -7,11 +7,10 @@ package tools.refinery.language.semantics.model.internal;
 
 import org.eclipse.collections.api.factory.primitive.IntObjectMaps;
 import tools.refinery.store.map.Cursor;
-import tools.refinery.store.reasoning.seed.Seed;
-import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
 
-public class DecisionTree implements Seed<TruthValue> {
+class DecisionTree implements MutableSeed<TruthValue> {
         private final int levels;
 
         private final DecisionTreeNode root;
@@ -50,26 +49,33 @@ public class DecisionTree implements Seed<TruthValue> {
                 return root.getValue(levels - 1, tuple).getTruthValue();
         }
 
+        @Override
         public void mergeValue(Tuple tuple, TruthValue truthValue) {
                 if (truthValue != null) {
                         root.mergeValue(levels - 1, tuple, truthValue);
                 }
         }
 
+        @Override
         public void setIfMissing(Tuple tuple, TruthValue truthValue) {
                 if (truthValue != null) {
                         root.setIfMissing(levels - 1, tuple, truthValue);
                 }
         }
 
+        @Override
         public void setAllMissing(TruthValue truthValue) {
                 if (truthValue != null) {
                         root.setAllMissing(truthValue);
                 }
         }
 
-        public void overwriteValues(DecisionTree values) {
-                root.overwriteValues(values.root);
+        @Override
+        public void overwriteValues(MutableSeed<TruthValue> values) {
+                if (!(values instanceof DecisionTree decisionTree)) {
+                        throw new IllegalArgumentException("Incompatible overwrite: " + values);
+                }
+                root.overwriteValues(decisionTree.root);
         }
 
         public TruthValue getReducedValue() {
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/MutableSeed.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/MutableSeed.java
new file mode 100644
index 00000000..99019e2a
--- /dev/null
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/MutableSeed.java
@@ -0,0 +1,28 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.semantics.model.internal;
+
+import tools.refinery.store.reasoning.seed.Seed;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+public interface MutableSeed<T> extends Seed<T> {
+        void mergeValue(Tuple tuple, T value);
+
+        void setIfMissing(Tuple tuple, T value);
+
+        void setAllMissing(T value);
+
+        void overwriteValues(MutableSeed<T> other);
+
+        static MutableSeed<TruthValue> of(int levels, TruthValue initialValue) {
+                if (levels == 0) {
+                        return new NullaryMutableSeed(initialValue);
+                } else {
+                        return new DecisionTree(levels, initialValue);
+                }
+        }
+}
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/NullaryMutableSeed.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/NullaryMutableSeed.java
new file mode 100644
index 00000000..80644b1f
--- /dev/null
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/internal/NullaryMutableSeed.java
@@ -0,0 +1,83 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.language.semantics.model.internal;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.Cursors;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+class NullaryMutableSeed implements MutableSeed<TruthValue> {
+        private DecisionTreeValue value;
+
+        public NullaryMutableSeed(TruthValue reducedValue) {
+
+                value = DecisionTreeValue.fromTruthValue(reducedValue);
+        }
+
+        @Override
+        public int arity() {
+                return 0;
+        }
+
+        @Override
+        public Class<TruthValue> valueType() {
+                return TruthValue.class;
+        }
+
+        @Override
+        public TruthValue reducedValue() {
+                return value.getTruthValue();
+        }
+
+        @Override
+        public TruthValue get(Tuple key) {
+                validateKey(key);
+                return reducedValue();
+        }
+
+        private static void validateKey(Tuple key) {
+                if (key.getSize() > 0) {
+                        throw new IllegalArgumentException("Invalid key: " + key);
+                }
+        }
+
+        @Override
+        public Cursor<Tuple, TruthValue> getCursor(TruthValue defaultValue, int nodeCount) {
+                if (value == DecisionTreeValue.UNSET || value.getTruthValue() == defaultValue) {
+                        return Cursors.empty();
+                }
+                return Cursors.singleton(Tuple.of(), value.getTruthValue());
+        }
+
+        @Override
+        public void mergeValue(Tuple tuple, TruthValue value) {
+                this.value = DecisionTreeValue.fromTruthValue(this.value.merge(value));
+        }
+
+        @Override
+        public void setIfMissing(Tuple tuple, TruthValue value) {
+                validateKey(tuple);
+                setAllMissing(value);
+        }
+
+        @Override
+        public void setAllMissing(TruthValue value) {
+                if (this.value == DecisionTreeValue.UNSET) {
+                        this.value = DecisionTreeValue.fromTruthValue(value);
+                }
+        }
+
+        @Override
+        public void overwriteValues(MutableSeed<TruthValue> other) {
+                if (!(other instanceof NullaryMutableSeed nullaryMutableSeed)) {
+                        throw new IllegalArgumentException("Incompatible overwrite: " + other);
+                }
+                if (nullaryMutableSeed.value != DecisionTreeValue.UNSET) {
+                        value = nullaryMutableSeed.value;
+                }
+        }
+}
diff --git a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/tests/DecisionTreeTests.java b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/internal/DecisionTreeTests.java
index 3c43d3bd..5d039308 100644
--- a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/tests/DecisionTreeTests.java
+++ b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/model/internal/DecisionTreeTests.java
@@ -3,10 +3,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.language.semantics.model.tests;
+package tools.refinery.language.semantics.model.internal;
 
 import org.junit.jupiter.api.Test;
-import tools.refinery.language.semantics.model.internal.DecisionTree;
 import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.tuple.Tuple;