3 files changed, 29 insertions, 13 deletions

diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
index 486eb89b..c2243f08 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ModelInitializer.java
@@ -52,7 +52,9 @@ import tools.refinery.store.reasoning.translator.multiplicity.ConstrainedMultipl
 import tools.refinery.store.reasoning.translator.multiplicity.Multiplicity;
 import tools.refinery.store.reasoning.translator.multiplicity.UnconstrainedMultiplicity;
 import tools.refinery.store.reasoning.translator.predicate.PredicateTranslator;
+import tools.refinery.store.statecoding.StateCoderBuilder;
 import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple1;
 
 import java.util.*;
 
@@ -78,6 +80,8 @@ public class ModelInitializer {
 
         private BuiltinSymbols builtinSymbols;
 
+        private final List<Tuple1> individuals = new ArrayList<>();
+
         private PartialRelation nodeRelation;
 
         private final Map<Relation, RelationInfo> relationInfoMap = new LinkedHashMap<>();
@@ -190,6 +194,8 @@ public class ModelInitializer {
                         }
                         collectPredicates(storeBuilder);
                         collectRules(storeBuilder);
+                        storeBuilder.tryGetAdapter(StateCoderBuilder.class)
+                                        .ifPresent(stateCoderBuilder -> stateCoderBuilder.individuals(individuals));
                 } catch (TranslationException e) {
                         throw problemTrace.wrapException(e);
                 }
@@ -224,29 +230,33 @@ public class ModelInitializer {
                         }
                 }
                 for (var node : problem.getNodes()) {
-                        collectNode(node);
+                        collectNode(node, false);
                 }
         }
 
         private void collectNodes(Statement statement) {
                 if (statement instanceof NodeDeclaration nodeDeclaration) {
+                        boolean individual = nodeDeclaration.getKind() == NodeKind.ATOM;
                         for (var node : nodeDeclaration.getNodes()) {
-                                collectNode(node);
+                                collectNode(node, individual);
                         }
                 } else if (statement instanceof ClassDeclaration classDeclaration) {
                         var newNode = classDeclaration.getNewNode();
                         if (newNode != null) {
-                                collectNode(newNode);
+                                collectNode(newNode, false);
                         }
                 } else if (statement instanceof EnumDeclaration enumDeclaration) {
                         for (var literal : enumDeclaration.getLiterals()) {
-                                collectNode(literal);
+                                collectNode(literal, true);
                         }
                 }
         }
 
-        private void collectNode(Node node) {
-                problemTrace.collectNode(node);
+        private void collectNode(Node node, boolean individual) {
+                int nodeId = problemTrace.collectNode(node);
+                if (individual) {
+                        individuals.add(Tuple.of(nodeId));
+                }
         }
 
         private void collectPartialSymbols() {
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ProblemTraceImpl.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ProblemTraceImpl.java
index 3a979bf0..4b44339c 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ProblemTraceImpl.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/ProblemTraceImpl.java
@@ -70,8 +70,10 @@ class ProblemTraceImpl implements ProblemTrace {
                 return nodeTrace;
         }
 
-        void collectNode(Node node) {
-                mutableNodeTrace.getIfAbsentPut(node, mutableNodeTrace.size());
+        int collectNode(Node node) {
+                var nextId = mutableNodeTrace.size();
+                mutableNodeTrace.getIfAbsentPut(node, nextId);
+                return nextId;
         }
 
         @Override
diff --git a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderBuilder.java b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderBuilder.java
index 54650825..868eddfc 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderBuilder.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/statecoding/StateCoderBuilder.java
@@ -10,34 +10,38 @@ import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.tuple.Tuple1;
 
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 
 public interface StateCoderBuilder extends ModelAdapterBuilder {
         StateCoderBuilder exclude(AnySymbol symbol);
+
         default StateCoderBuilder excludeAll(Collection<? extends AnySymbol> symbols) {
-                for(var symbol : symbols) {
+                for (var symbol : symbols) {
                         exclude(symbol);
                 }
                 return this;
         }
+
         default StateCoderBuilder excludeAll(AnySymbol... symbols) {
                 return excludeAll(List.of(symbols));
         }
 
         StateCoderBuilder individual(Tuple1 tuple);
-        default StateCoderBuilder individual(Collection<Tuple1> tuple1s) {
-                for(Tuple1 tuple : tuple1s){
+
+        default StateCoderBuilder individuals(Collection<Tuple1> tuple1s) {
+                for (Tuple1 tuple : tuple1s) {
                         individual(tuple);
                 }
                 return this;
         }
+
         default StateCoderBuilder individuals(Tuple1... tuple1s) {
-                return individual(Arrays.stream(tuple1s).toList());
+                return individuals(List.of(tuple1s));
         }
 
         StateCoderBuilder stateCodeCalculatorFactory(StateCodeCalculatorFactory codeCalculatorFactory);
+
         StateCoderBuilder stateEquivalenceChecker(StateEquivalenceChecker stateEquivalenceChecker);
 
         @Override