refactor: candidate interpreation only on demand

Avoid creating interpretations not needed for the graph analysis task.

10 files changed, 84 insertions, 20 deletions

diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java
index c828b3d5..2495430e 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java
@@ -65,7 +65,8 @@ public class SemanticsService extends AbstractCachedService<SemanticsResult> {
                 var initializer = initializerProvider.get();
                 var builder = ModelStore.builder()
                                 .with(ViatraModelQueryAdapter.builder())
-                                .with(ReasoningAdapter.builder());
+                                .with(ReasoningAdapter.builder()
+                                                .requiredInterpretations(Concreteness.PARTIAL));
                 operationCanceledManager.checkCanceled(cancelIndicator);
                 try {
                         var modelSeed = initializer.createModel(problem, builder);
@@ -84,7 +85,7 @@ public class SemanticsService extends AbstractCachedService<SemanticsResult> {
                         }
                         return new SemanticsSuccessResult(nodeTrace, partialInterpretation);
                 } catch (RuntimeException e) {
-                        LOG.error("Error while computing semantics", e);
+                        LOG.debug("Error while computing semantics", e);
                         return new SemanticsErrorResult(e.getMessage());
                 }
         }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningBuilder.java
index f560c74c..3d4c672f 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningBuilder.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningBuilder.java
@@ -18,8 +18,17 @@ import tools.refinery.store.reasoning.refinement.StorageRefiner;
 import tools.refinery.store.reasoning.translator.AnyPartialSymbolTranslator;
 import tools.refinery.store.representation.Symbol;
 
+import java.util.Collection;
+import java.util.List;
+
 @SuppressWarnings("UnusedReturnValue")
 public interface ReasoningBuilder extends ModelAdapterBuilder {
+        ReasoningBuilder requiredInterpretations(Collection<Concreteness> requiredInterpretations);
+
+        default ReasoningBuilder requiredInterpretations(Concreteness... requiredInterpretations) {
+                return requiredInterpretations(List.of(requiredInterpretations));
+        }
+
         ReasoningBuilder partialSymbol(AnyPartialSymbolTranslator translator);
 
         <T> ReasoningBuilder storageRefiner(Symbol<T> symbol, StorageRefiner.Factory<T> refiner);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java
index 6f9354eb..fe3cc3ea 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java
@@ -7,16 +7,20 @@ package tools.refinery.store.reasoning;
 
 import tools.refinery.store.adapter.ModelStoreAdapter;
 import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.seed.ModelSeed;
 
 import java.util.Collection;
+import java.util.Set;
 
 public interface ReasoningStoreAdapter extends ModelStoreAdapter {
         Collection<AnyPartialSymbol> getPartialSymbols();
 
         Collection<AnyPartialSymbol> getRefinablePartialSymbols();
 
+        Set<Concreteness> getSupportedInterpretations();
+
         Model createInitialModel(ModelSeed modelSeed);
 
         @Override
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
index 579b08dd..2fa744de 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
@@ -48,16 +48,20 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
                 refiners = new HashMap<>(refinerFactories.size());
                 createRefiners();
 
-                storageRefiners = storeAdapter.createStprageRefiner(model);
+                storageRefiners = storeAdapter.createStorageRefiner(model);
 
                 nodeCountInterpretation = model.getInterpretation(NODE_COUNT_SYMBOL);
         }
 
         private void createPartialInterpretations() {
+                var supportedInterpretations = storeAdapter.getSupportedInterpretations();
                 int concretenessLength = Concreteness.values().length;
                 var interpretationFactories = storeAdapter.getSymbolInterpreters();
                 for (int i = 0; i < concretenessLength; i++) {
-                        partialInterpretations[i] = new HashMap<>(interpretationFactories.size());
+                        var concreteness = Concreteness.values()[i];
+                        if (supportedInterpretations.contains(concreteness)) {
+                                partialInterpretations[i] = new HashMap<>(interpretationFactories.size());
+                        }
                 }
                 // Create the partial interpretations in order so that factories may refer to interpretations of symbols
                 // preceding them in the ordered {@code interpretationFactories} map, e.g., for opposite interpretations.
@@ -65,9 +69,11 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
                         var partialSymbol = entry.getKey();
                         var factory = entry.getValue();
                         for (int i = 0; i < concretenessLength; i++) {
-                                var concreteness = Concreteness.values()[i];
-                                var interpretation = createPartialInterpretation(concreteness, factory, partialSymbol);
-                                partialInterpretations[i].put(partialSymbol, interpretation);
+                                if (partialInterpretations[i] != null) {
+                                        var concreteness = Concreteness.values()[i];
+                                        var interpretation = createPartialInterpretation(concreteness, factory, partialSymbol);
+                                        partialInterpretations[i].put(partialSymbol, interpretation);
+                                }
                         }
                 }
         }
@@ -114,6 +120,9 @@ class ReasoningAdapterImpl implements ReasoningAdapter {
         public <A, C> PartialInterpretation<A, C> getPartialInterpretation(Concreteness concreteness,
                                                                                                                                            PartialSymbol<A, C> partialSymbol) {
                 var map = partialInterpretations[concreteness.ordinal()];
+                if (map == null) {
+                        throw new IllegalArgumentException("No interpretation for concreteness: " + concreteness);
+                }
                 var interpretation = map.get(partialSymbol);
                 if (interpretation == null) {
                         throw new IllegalArgumentException("No interpretation for partial symbol: " + partialSymbol);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningBuilderImpl.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningBuilderImpl.java
index 2af84e2d..b4971d2c 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningBuilderImpl.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningBuilderImpl.java
@@ -34,6 +34,7 @@ public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder<ReasoningS
                 implements ReasoningBuilder {
         private final DnfLifter lifter = new DnfLifter();
         private final PartialQueryRewriter queryRewriter = new PartialQueryRewriter(lifter);
+        private Set<Concreteness> requiredInterpretations = Set.of(Concreteness.values());
         private final Map<AnyPartialSymbol, AnyPartialSymbolTranslator> translators = new LinkedHashMap<>();
         private final Map<AnyPartialSymbol, PartialInterpretation.Factory<?, ?>> symbolInterpreters = new LinkedHashMap<>();
         private final Map<AnyPartialSymbol, PartialInterpretationRefiner.Factory<?, ?>> symbolRefiners =
@@ -42,6 +43,12 @@ public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder<ReasoningS
         private final List<PartialModelInitializer> initializers = new ArrayList<>();
 
         @Override
+        public ReasoningBuilder requiredInterpretations(Collection<Concreteness> requiredInterpretations) {
+                this.requiredInterpretations = Set.copyOf(requiredInterpretations);
+                return this;
+        }
+
+        @Override
         public ReasoningBuilder partialSymbol(AnyPartialSymbolTranslator translator) {
                 var partialSymbol = translator.getPartialSymbol();
                 var oldConfiguration = translators.put(partialSymbol, translator);
@@ -93,7 +100,7 @@ public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder<ReasoningS
                 for (var translator : translators.values()) {
                         translator.configure(storeBuilder);
                         if (translator instanceof PartialRelationTranslator relationConfiguration) {
-                                doConfigure(relationConfiguration);
+                                doConfigure(storeBuilder, relationConfiguration);
                         } else {
                                 throw new IllegalArgumentException("Unknown partial symbol translator %s for partial symbol %s"
                                                 .formatted(translator, translator.getPartialSymbol()));
@@ -104,10 +111,12 @@ public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder<ReasoningS
                 queryBuilder.rewriter(queryRewriter);
         }
 
-        private void doConfigure(PartialRelationTranslator relationConfiguration) {
+        private void doConfigure(ModelStoreBuilder storeBuilder, PartialRelationTranslator relationConfiguration) {
                 var partialRelation = relationConfiguration.getPartialRelation();
                 queryRewriter.addRelationRewriter(partialRelation, relationConfiguration.getRewriter());
-                symbolInterpreters.put(partialRelation, relationConfiguration.getInterpretationFactory());
+                var interpretationFactory = relationConfiguration.getInterpretationFactory();
+                interpretationFactory.configure(storeBuilder, requiredInterpretations);
+                symbolInterpreters.put(partialRelation, interpretationFactory);
                 var refiner = relationConfiguration.getInterpretationRefiner();
                 if (refiner != null) {
                         symbolRefiners.put(partialRelation, refiner);
@@ -116,9 +125,9 @@ public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder<ReasoningS
 
         @Override
         public ReasoningStoreAdapterImpl doBuild(ModelStore store) {
-                return new ReasoningStoreAdapterImpl(store, Collections.unmodifiableMap(symbolInterpreters),
-                                Collections.unmodifiableMap(symbolRefiners), getStorageRefiners(store),
-                                Collections.unmodifiableList(initializers));
+                return new ReasoningStoreAdapterImpl(store, requiredInterpretations,
+                                Collections.unmodifiableMap(symbolInterpreters), Collections.unmodifiableMap(symbolRefiners),
+                                getStorageRefiners(store), Collections.unmodifiableList(initializers));
         }
 
         private Map<AnySymbol, StorageRefiner.Factory<?>> getStorageRefiners(ModelStore store) {
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java
index 3dac53ef..8eb5a034 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java
@@ -10,6 +10,7 @@ import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.ModelQueryAdapter;
 import tools.refinery.store.reasoning.ReasoningStoreAdapter;
 import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
+import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.refinement.PartialInterpretationRefiner;
 import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
 import tools.refinery.store.reasoning.refinement.StorageRefiner;
@@ -22,20 +23,23 @@ import tools.refinery.store.tuple.Tuple;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 class ReasoningStoreAdapterImpl implements ReasoningStoreAdapter {
         private final ModelStore store;
+        private final Set<Concreteness> supportedInterpretations;
         private final Map<AnyPartialSymbol, PartialInterpretation.Factory<?, ?>> symbolInterpreters;
         private final Map<AnyPartialSymbol, PartialInterpretationRefiner.Factory<?, ?>> symbolRefiners;
         private final Map<AnySymbol, StorageRefiner.Factory<?>> storageRefiners;
         private final List<PartialModelInitializer> initializers;
 
-        ReasoningStoreAdapterImpl(ModelStore store,
+        ReasoningStoreAdapterImpl(ModelStore store, Set<Concreteness> supportedInterpretations,
                                                           Map<AnyPartialSymbol, PartialInterpretation.Factory<?, ?>> symbolInterpreters,
                                                           Map<AnyPartialSymbol, PartialInterpretationRefiner.Factory<?, ?>> symbolRefiners,
                                                           Map<AnySymbol, StorageRefiner.Factory<?>> storageRefiners,
                                                           List<PartialModelInitializer> initializers) {
                 this.store = store;
+                this.supportedInterpretations = supportedInterpretations;
                 this.symbolInterpreters = symbolInterpreters;
                 this.symbolRefiners = symbolRefiners;
                 this.storageRefiners = storageRefiners;
@@ -48,6 +52,11 @@ class ReasoningStoreAdapterImpl implements ReasoningStoreAdapter {
         }
 
         @Override
+        public Set<Concreteness> getSupportedInterpretations() {
+                return supportedInterpretations;
+        }
+
+        @Override
         public Collection<AnyPartialSymbol> getPartialSymbols() {
                 return symbolInterpreters.keySet();
         }
@@ -69,7 +78,7 @@ class ReasoningStoreAdapterImpl implements ReasoningStoreAdapter {
                 return symbolRefiners;
         }
 
-        StorageRefiner[] createStprageRefiner(Model model) {
+        StorageRefiner[] createStorageRefiner(Model model) {
                 var refiners = new StorageRefiner[storageRefiners.size()];
                 int i = 0;
                 for (var entry : storageRefiners.entrySet()) {
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/PartialInterpretation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/PartialInterpretation.java
index 3d3d6056..86ffe751 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/PartialInterpretation.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/PartialInterpretation.java
@@ -6,11 +6,14 @@
 package tools.refinery.store.reasoning.interpretation;
 
 import tools.refinery.store.map.Cursor;
+import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.representation.PartialSymbol;
 import tools.refinery.store.tuple.Tuple;
 
+import java.util.Set;
+
 public non-sealed interface PartialInterpretation<A, C> extends AnyPartialInterpretation {
         @Override
         PartialSymbol<A, C> getPartialSymbol();
@@ -19,8 +22,13 @@ public non-sealed interface PartialInterpretation<A, C> extends AnyPartialInterp
 
         Cursor<Tuple, A> getAll();
 
+        @FunctionalInterface
         interface Factory<A, C> {
                 PartialInterpretation<A, C> create(ReasoningAdapter adapter, Concreteness concreteness,
                                                                                    PartialSymbol<A, C> partialSymbol);
+
+                default void configure(ModelStoreBuilder storeBuilder, Set<Concreteness> requiredInterpretations) {
+                        // Nothing to configure by default.
+                }
         }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/QueryBasedRelationInterpretationFactory.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/QueryBasedRelationInterpretationFactory.java
index 2535714a..5cdaa185 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/QueryBasedRelationInterpretationFactory.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/interpretation/QueryBasedRelationInterpretationFactory.java
@@ -6,7 +6,9 @@
 package tools.refinery.store.reasoning.interpretation;
 
 import tools.refinery.store.map.Cursor;
+import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.ModelQueryBuilder;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.resultset.ResultSet;
 import tools.refinery.store.reasoning.ReasoningAdapter;
@@ -15,6 +17,8 @@ import tools.refinery.store.reasoning.representation.PartialSymbol;
 import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.tuple.Tuple;
 
+import java.util.Set;
+
 public class QueryBasedRelationInterpretationFactory implements PartialInterpretation.Factory<TruthValue, Boolean> {
         private final Query<Boolean> may;
         private final Query<Boolean> must;
@@ -54,6 +58,17 @@ public class QueryBasedRelationInterpretationFactory implements PartialInterpret
                 }
         }
 
+        @Override
+        public void configure(ModelStoreBuilder storeBuilder, Set<Concreteness> requiredInterpretations) {
+                var queryBuilder = storeBuilder.getAdapter(ModelQueryBuilder.class);
+                if (requiredInterpretations.contains(Concreteness.PARTIAL)) {
+                        queryBuilder.queries(may, must);
+                }
+                if (requiredInterpretations.contains(Concreteness.CANDIDATE)) {
+                        queryBuilder.queries(candidateMay, candidateMust);
+                }
+        }
+
         private static class TwoValuedInterpretation extends AbstractPartialInterpretation<TruthValue, Boolean> {
                 private final ResultSet<Boolean> resultSet;
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialRelationTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialRelationTranslator.java
index 6f9492a3..4600d5a4 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialRelationTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialRelationTranslator.java
@@ -7,7 +7,6 @@ package tools.refinery.store.reasoning.translator;
 
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.query.Constraint;
-import tools.refinery.store.query.ModelQueryBuilder;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.dnf.QueryBuilder;
 import tools.refinery.store.query.dnf.RelationalQuery;
@@ -169,7 +168,7 @@ public final class PartialRelationTranslator extends PartialSymbolTranslator<Tru
                 createFallbackQueriesFromSymbol();
                 setFallbackCandidateQueries();
                 createFallbackRewriter();
-                createFallbackInterpretation(storeBuilder);
+                createFallbackInterpretation();
                 createFallbackRefiner();
                 super.doConfigure(storeBuilder);
         }
@@ -279,11 +278,9 @@ public final class PartialRelationTranslator extends PartialSymbolTranslator<Tru
                 }
         }
 
-        private void createFallbackInterpretation(ModelStoreBuilder storeBuilder) {
+        private void createFallbackInterpretation() {
                 if (interpretationFactory == null) {
-                        var queryBuilder = storeBuilder.getAdapter(ModelQueryBuilder.class);
                         interpretationFactory = new QueryBasedRelationInterpretationFactory(may, must, candidateMay, candidateMust);
-                        queryBuilder.queries(may, must, candidateMay, candidateMust);
                 }
         }
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialSymbolTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialSymbolTranslator.java
index 542acdb3..e7e26cb2 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialSymbolTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/PartialSymbolTranslator.java
@@ -8,6 +8,7 @@ package tools.refinery.store.reasoning.translator;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.reasoning.ReasoningBuilder;
 import tools.refinery.store.reasoning.interpretation.PartialInterpretation;
+import tools.refinery.store.reasoning.literal.Concreteness;
 import tools.refinery.store.reasoning.refinement.PartialInterpretationRefiner;
 import tools.refinery.store.reasoning.refinement.PartialModelInitializer;
 import tools.refinery.store.reasoning.refinement.StorageRefiner;
@@ -16,6 +17,8 @@ import tools.refinery.store.reasoning.seed.SeedInitializer;
 import tools.refinery.store.representation.AnySymbol;
 import tools.refinery.store.representation.Symbol;
 
+import java.util.Set;
+
 @SuppressWarnings("UnusedReturnValue")
 public abstract sealed class PartialSymbolTranslator<A, C> implements AnyPartialSymbolTranslator
                 permits PartialRelationTranslator {