feat: terms and improved query evaluation

* Implement data terms for computations in queries.
* Function-like queries with computed results.
* Improved query evaluation, including positive and negative diagonal
  cosntraints.
* Preliminary local search support.
* Changes to the DNF representation for count and aggregation support.

feat: terms wip

feat: query terms wip

feat: query evaluation, diagonal constraints, local search wip

fix reasoning compilation wip

28 files changed, 371 insertions, 316 deletions

diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/PartialInterpretation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/PartialInterpretation.java
index 99656da8..4f195e97 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/PartialInterpretation.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/PartialInterpretation.java
@@ -12,8 +12,6 @@ public non-sealed interface PartialInterpretation<A, C> extends AnyPartialInterp
 
         Cursor<Tuple, A> getAll();
 
-        Cursor<Tuple, A> getAllErrors();
-
         MergeResult merge(Tuple key, A value);
 
         C getConcrete(Tuple key);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java
index e602242e..de039dd9 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java
@@ -3,7 +3,7 @@ package tools.refinery.store.reasoning;
 import tools.refinery.store.adapter.ModelAdapter;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.representation.PartialSymbol;
-import tools.refinery.store.query.Dnf;
+import tools.refinery.store.query.dnf.Dnf;
 import tools.refinery.store.query.ResultSet;
 
 public interface ReasoningAdapter extends ModelAdapter {
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 588c2711..4030d296 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
@@ -3,7 +3,7 @@ package tools.refinery.store.reasoning;
 import tools.refinery.store.adapter.ModelAdapterBuilder;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.reasoning.literal.Modality;
-import tools.refinery.store.query.Dnf;
+import tools.refinery.store.query.dnf.Dnf;
 
 import java.util.Collection;
 import java.util.List;
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 69c0f5eb..f6a6e414 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
@@ -3,7 +3,7 @@ package tools.refinery.store.reasoning;
 import tools.refinery.store.adapter.ModelStoreAdapter;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
-import tools.refinery.store.query.Dnf;
+import tools.refinery.store.query.dnf.Dnf;
 
 import java.util.Collection;
 
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 a7a56680..0acf0d49 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
@@ -4,7 +4,7 @@ import tools.refinery.store.model.Model;
 import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.PartialInterpretation;
 import tools.refinery.store.reasoning.representation.PartialSymbol;
-import tools.refinery.store.query.Dnf;
+import tools.refinery.store.query.dnf.Dnf;
 import tools.refinery.store.query.ResultSet;
 
 public class ReasoningAdapterImpl implements ReasoningAdapter {
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 2860e2b9..e11b14bf 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
@@ -5,7 +5,7 @@ import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreBuilder;
 import tools.refinery.store.reasoning.ReasoningBuilder;
 import tools.refinery.store.reasoning.literal.Modality;
-import tools.refinery.store.query.Dnf;
+import tools.refinery.store.query.dnf.Dnf;
 
 public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder implements ReasoningBuilder {
         public ReasoningBuilderImpl(ModelStoreBuilder storeBuilder) {
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 763dad6d..ac06e68b 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
@@ -4,7 +4,7 @@ import tools.refinery.store.reasoning.ReasoningStoreAdapter;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
-import tools.refinery.store.query.Dnf;
+import tools.refinery.store.query.dnf.Dnf;
 
 import java.util.Collection;
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/DnfLifter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/DnfLifter.java
index 966e080a..2b0e0f08 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/DnfLifter.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/DnfLifter.java
@@ -1,18 +1,18 @@
 package tools.refinery.store.reasoning.lifting;
 
 import org.jetbrains.annotations.Nullable;
-import tools.refinery.store.reasoning.literal.ModalDnfCallLiteral;
-import tools.refinery.store.reasoning.Reasoning;
-import tools.refinery.store.reasoning.literal.ModalRelationLiteral;
-import tools.refinery.store.reasoning.literal.PartialRelationLiteral;
-import tools.refinery.store.query.Dnf;
-import tools.refinery.store.query.DnfBuilder;
-import tools.refinery.store.query.DnfClause;
-import tools.refinery.store.query.Variable;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.DnfBuilder;
+import tools.refinery.store.query.dnf.DnfClause;
+import tools.refinery.store.query.literal.CallLiteral;
 import tools.refinery.store.query.literal.CallPolarity;
-import tools.refinery.store.query.literal.DnfCallLiteral;
 import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.reasoning.Reasoning;
+import tools.refinery.store.reasoning.literal.ModalConstraint;
 import tools.refinery.store.reasoning.literal.Modality;
+import tools.refinery.store.reasoning.literal.PartialLiterals;
 import tools.refinery.store.util.CycleDetectingMapper;
 
 import java.util.ArrayList;
@@ -46,7 +46,10 @@ public class DnfLifter {
 
         private boolean liftClause(Modality modality, DnfClause clause, DnfBuilder builder) {
                 boolean changed = false;
-                var quantifiedVariables = new HashSet<>(clause.quantifiedVariables());
+                var quantifiedVariables = new HashSet<>(clause.boundVariables()
+                                .stream()
+                                .filter(DataVariable.class::isInstance)
+                                .toList());
                 var literals = clause.literals();
                 var liftedLiterals = new ArrayList<Literal>(literals.size());
                 for (var literal : literals) {
@@ -65,8 +68,8 @@ public class DnfLifter {
                         }
                 }
                 for (var quantifiedVariable : quantifiedVariables) {
-                        // Quantify over variables that are not already quantified with the expected modality.
-                        liftedLiterals.add(Reasoning.EXISTS.call(CallPolarity.POSITIVE, modality,
+                        // Quantify over data variables that are not already quantified with the expected modality.
+                        liftedLiterals.add(new CallLiteral(CallPolarity.POSITIVE, new ModalConstraint(modality, Reasoning.EXISTS),
                                         List.of(quantifiedVariable)));
                 }
                 builder.clause(liftedLiterals);
@@ -75,33 +78,39 @@ public class DnfLifter {
 
         @Nullable
         private Variable isExistsLiteralForVariable(Modality modality, Literal literal) {
-                if (literal instanceof ModalRelationLiteral modalRelationLiteral &&
-                                modalRelationLiteral.getPolarity() == CallPolarity.POSITIVE &&
-                                modalRelationLiteral.getModality() == modality &&
-                                modalRelationLiteral.getTarget().equals(Reasoning.EXISTS)) {
-                        return modalRelationLiteral.getArguments().get(0);
+                if (literal instanceof CallLiteral callLiteral &&
+                                callLiteral.getPolarity() == CallPolarity.POSITIVE &&
+                                callLiteral.getTarget() instanceof ModalConstraint modalConstraint &&
+                                modalConstraint.modality() == modality &&
+                                modalConstraint.constraint().equals(Reasoning.EXISTS)) {
+                        return callLiteral.getArguments().get(0);
                 }
                 return null;
         }
 
         @Nullable
         private Literal liftLiteral(Modality modality, Literal literal) {
-                if (literal instanceof PartialRelationLiteral partialRelationLiteral) {
-                        return new ModalRelationLiteral(modality, partialRelationLiteral);
-                } else if (literal instanceof DnfCallLiteral dnfCallLiteral) {
-                        var polarity = dnfCallLiteral.getPolarity();
-                        var target = dnfCallLiteral.getTarget();
-                        var liftedTarget = lift(modality.commute(polarity), target);
-                        if (target.equals(liftedTarget)) {
-                                return null;
+                if (!(literal instanceof CallLiteral callLiteral)) {
+                        return null;
+                }
+                var target = callLiteral.getTarget();
+                if (target instanceof ModalConstraint modalTarget) {
+                        var actualTarget = modalTarget.constraint();
+                        if (actualTarget instanceof Dnf dnf) {
+                                var targetModality = modalTarget.modality();
+                                var liftedTarget = lift(targetModality, dnf);
+                                return new CallLiteral(callLiteral.getPolarity(), liftedTarget, callLiteral.getArguments());
                         }
-                        return new DnfCallLiteral(polarity, liftedTarget, dnfCallLiteral.getArguments());
-                } else if (literal instanceof ModalDnfCallLiteral modalDnfCallLiteral) {
-                        var liftedTarget = lift(modalDnfCallLiteral.getModality(), modalDnfCallLiteral.getTarget());
-                        return new DnfCallLiteral(modalDnfCallLiteral.getPolarity(), liftedTarget,
-                                        modalDnfCallLiteral.getArguments());
-                } else {
+                        // No more lifting to be done, pass any modal call to a partial symbol through.
                         return null;
+                } else if (target instanceof Dnf dnf) {
+                        var polarity = callLiteral.getPolarity();
+                        var liftedTarget = lift(modality.commute(polarity), dnf);
+                        // Use == instead of equals(), because lift will return the same object by reference is there are no
+                        // changes made during lifting.
+                        return liftedTarget == target ? null : new CallLiteral(polarity, liftedTarget, callLiteral.getArguments());
+                } else {
+                        return PartialLiterals.addModality(callLiteral, modality);
                 }
         }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/ModalDnf.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/ModalDnf.java
index 7aa98bf2..ec381bb8 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/ModalDnf.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/ModalDnf.java
@@ -1,9 +1,9 @@
 package tools.refinery.store.reasoning.lifting;
 
-import tools.refinery.store.query.Dnf;
+import tools.refinery.store.query.dnf.Dnf;
 import tools.refinery.store.reasoning.literal.Modality;
 
-public record ModalDnf(Modality modality, Dnf dnf) {
+record ModalDnf(Modality modality, Dnf dnf) {
         @Override
         public String toString() {
                 return "%s %s".formatted(modality, dnf.name());
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java
new file mode 100644
index 00000000..2fbb4607
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java
@@ -0,0 +1,46 @@
+package tools.refinery.store.reasoning.literal;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.literal.LiteralReduction;
+import tools.refinery.store.query.term.Sort;
+
+import java.util.List;
+
+public record ModalConstraint(Modality modality, Constraint constraint) implements Constraint {
+        private static final String FORMAT = "%s %s";
+
+        @Override
+        public String name() {
+                return FORMAT.formatted(modality, constraint.name());
+        }
+
+        @Override
+        public List<Sort> getSorts() {
+                return constraint.getSorts();
+        }
+
+        @Override
+        public LiteralReduction getReduction() {
+                return constraint.getReduction();
+        }
+
+        @Override
+        public boolean equals(LiteralEqualityHelper helper, Constraint other) {
+                if (getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherModalConstraint = (ModalConstraint) other;
+                return modality == otherModalConstraint.modality && constraint.equals(helper, otherModalConstraint.constraint);
+        }
+
+        @Override
+        public String toReferenceString() {
+                return FORMAT.formatted(modality, constraint.toReferenceString());
+        }
+
+        @Override
+        public String toString() {
+                return FORMAT.formatted(modality, constraint);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalDnfCallLiteral.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalDnfCallLiteral.java
deleted file mode 100644
index 1090f1ae..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalDnfCallLiteral.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package tools.refinery.store.reasoning.literal;
-
-import tools.refinery.store.query.Dnf;
-import tools.refinery.store.query.Variable;
-import tools.refinery.store.query.equality.LiteralEqualityHelper;
-import tools.refinery.store.query.literal.CallPolarity;
-import tools.refinery.store.query.literal.DnfCallLiteral;
-import tools.refinery.store.query.literal.LiteralReduction;
-import tools.refinery.store.query.literal.PolarLiteral;
-import tools.refinery.store.query.substitution.Substitution;
-
-import java.util.List;
-
-public class ModalDnfCallLiteral extends ModalLiteral<Dnf> implements PolarLiteral<ModalDnfCallLiteral> {
-        public ModalDnfCallLiteral(CallPolarity polarity, Modality modality, Dnf target, List<Variable> arguments) {
-                super(polarity, modality, target, arguments);
-        }
-
-        public ModalDnfCallLiteral(Modality modality, DnfCallLiteral baseLiteral) {
-                super(modality.commute(baseLiteral.getPolarity()), baseLiteral);
-        }
-
-        @Override
-        public Class<Dnf> getTargetType() {
-                return Dnf.class;
-        }
-
-        @Override
-        protected boolean targetEquals(LiteralEqualityHelper helper, Dnf otherTarget) {
-                return helper.dnfEqual(getTarget(), otherTarget);
-        }
-
-        @Override
-        public ModalDnfCallLiteral substitute(Substitution substitution) {
-                return new ModalDnfCallLiteral(getPolarity(), getModality(), getTarget(), substituteArguments(substitution));
-        }
-
-        @Override
-        public ModalDnfCallLiteral negate() {
-                return new ModalDnfCallLiteral(getPolarity().negate(), getModality(), getTarget(), getArguments());
-        }
-
-        @Override
-        public LiteralReduction getReduction() {
-                var dnfReduction = getTarget().getReduction();
-                return getPolarity().isPositive() ? dnfReduction : dnfReduction.negate();
-        }
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalLiteral.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalLiteral.java
deleted file mode 100644
index 5992f172..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalLiteral.java
+++ /dev/null
@@ -1,63 +0,0 @@
-package tools.refinery.store.reasoning.literal;
-
-import tools.refinery.store.query.RelationLike;
-import tools.refinery.store.query.Variable;
-import tools.refinery.store.query.equality.LiteralEqualityHelper;
-import tools.refinery.store.query.literal.CallLiteral;
-import tools.refinery.store.query.literal.CallPolarity;
-import tools.refinery.store.query.literal.Literal;
-
-import java.util.List;
-import java.util.Objects;
-
-public abstract class ModalLiteral<T extends RelationLike> extends CallLiteral<T> {
-        private final Modality modality;
-
-        protected ModalLiteral(CallPolarity polarity, Modality modality, T target, List<Variable> arguments) {
-                super(polarity, target, arguments);
-                this.modality = modality;
-        }
-
-        protected ModalLiteral(Modality modality, CallLiteral<? extends T> baseLiteral) {
-                this(baseLiteral.getPolarity(), commute(modality, baseLiteral.getPolarity()), baseLiteral.getTarget(),
-                                baseLiteral.getArguments());
-        }
-
-        public Modality getModality() {
-                return modality;
-        }
-
-        @Override
-        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other) {
-                if (!super.equalsWithSubstitution(helper, other)) {
-                        return false;
-                }
-                // If {@link CallLiteral#equalsWithSubstitution(LiteralEqualityHelper, Literal)} has returned {@code true},
-                // we must have the same dynamic type as {@code other}.
-                var otherModalLiteral = (ModalLiteral<?>) other;
-                return modality == otherModalLiteral.modality;
-        }
-
-        @Override
-        protected String targetToString() {
-                return "%s %s".formatted(modality, super.targetToString());
-        }
-
-        @Override
-        public boolean equals(Object o) {
-                if (this == o) return true;
-                if (o == null || getClass() != o.getClass()) return false;
-                if (!super.equals(o)) return false;
-                ModalLiteral<?> that = (ModalLiteral<?>) o;
-                return modality == that.modality;
-        }
-
-        @Override
-        public int hashCode() {
-                return Objects.hash(super.hashCode(), modality);
-        }
-
-        private static Modality commute(Modality modality, CallPolarity polarity) {
-                return polarity.isPositive() ? modality : modality.negate();
-        }
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalRelationLiteral.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalRelationLiteral.java
deleted file mode 100644
index 9c72bd37..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalRelationLiteral.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package tools.refinery.store.reasoning.literal;
-
-import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.query.Variable;
-import tools.refinery.store.query.literal.CallPolarity;
-import tools.refinery.store.query.literal.PolarLiteral;
-import tools.refinery.store.query.substitution.Substitution;
-
-import java.util.List;
-
-public final class ModalRelationLiteral extends ModalLiteral<PartialRelation>
-                implements PolarLiteral<ModalRelationLiteral> {
-        public ModalRelationLiteral(CallPolarity polarity, Modality modality, PartialRelation target,
-                                                 List<Variable> arguments) {
-                super(polarity, modality, target, arguments);
-        }
-
-
-        public ModalRelationLiteral(Modality modality, PartialRelationLiteral baseLiteral) {
-                super(modality, baseLiteral);
-        }
-
-        @Override
-        public Class<PartialRelation> getTargetType() {
-                return PartialRelation.class;
-        }
-
-        @Override
-        public ModalRelationLiteral substitute(Substitution substitution) {
-                return new ModalRelationLiteral(getPolarity(), getModality(), getTarget(), substituteArguments(substitution));
-        }
-
-        @Override
-        public ModalRelationLiteral negate() {
-                return new ModalRelationLiteral(getPolarity().negate(), getModality(), getTarget(), getArguments());
-        }
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java
index 10e4c7f7..f991f87f 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java
@@ -1,33 +1,31 @@
 package tools.refinery.store.reasoning.literal;
 
-import tools.refinery.store.query.literal.DnfCallLiteral;
+import tools.refinery.store.query.literal.CallLiteral;
 
 public final class PartialLiterals {
         private PartialLiterals() {
                 throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
         }
 
-        public ModalRelationLiteral may(PartialRelationLiteral literal) {
-                return new ModalRelationLiteral(Modality.MAY, literal);
+        public static CallLiteral may(CallLiteral literal) {
+                return addModality(literal, Modality.MAY);
         }
 
-        public ModalRelationLiteral must(PartialRelationLiteral literal) {
-                return new ModalRelationLiteral(Modality.MUST, literal);
+        public static CallLiteral must(CallLiteral literal) {
+                return addModality(literal, Modality.MUST);
         }
 
-        public ModalRelationLiteral current(PartialRelationLiteral literal) {
-                return new ModalRelationLiteral(Modality.CURRENT, literal);
+        public static CallLiteral current(CallLiteral literal) {
+                return addModality(literal, Modality.CURRENT);
         }
 
-        public ModalDnfCallLiteral may(DnfCallLiteral literal) {
-                return new ModalDnfCallLiteral(Modality.MAY, literal);
-        }
-
-        public ModalDnfCallLiteral must(DnfCallLiteral literal) {
-                return new ModalDnfCallLiteral(Modality.MUST, literal);
-        }
-
-        public ModalDnfCallLiteral current(DnfCallLiteral literal) {
-                return new ModalDnfCallLiteral(Modality.CURRENT, literal);
+        public static CallLiteral addModality(CallLiteral literal, Modality modality) {
+                var target = literal.getTarget();
+                if (target instanceof ModalConstraint) {
+                        throw new IllegalArgumentException("Literal %s already has modality".formatted(literal));
+                }
+                var polarity = literal.getPolarity();
+                var modalTarget = new ModalConstraint(modality.commute(polarity), target);
+                return new CallLiteral(polarity, modalTarget, literal.getArguments());
         }
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialRelationLiteral.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialRelationLiteral.java
deleted file mode 100644
index aff84538..00000000
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialRelationLiteral.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package tools.refinery.store.reasoning.literal;
-
-import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.query.Variable;
-import tools.refinery.store.query.literal.CallLiteral;
-import tools.refinery.store.query.literal.CallPolarity;
-import tools.refinery.store.query.literal.PolarLiteral;
-import tools.refinery.store.query.substitution.Substitution;
-
-import java.util.List;
-
-public final class PartialRelationLiteral extends CallLiteral<PartialRelation>
-                implements PolarLiteral<PartialRelationLiteral> {
-        public PartialRelationLiteral(CallPolarity polarity, PartialRelation target, List<Variable> substitution) {
-                super(polarity, target, substitution);
-        }
-
-        @Override
-        public Class<PartialRelation> getTargetType() {
-                return PartialRelation.class;
-        }
-
-        @Override
-        public PartialRelationLiteral substitute(Substitution substitution) {
-                return new PartialRelationLiteral(getPolarity(), getTarget(), substituteArguments(substitution));
-        }
-
-        @Override
-        public PartialRelationLiteral negate() {
-                return new PartialRelationLiteral(getPolarity().negate(), getTarget(), getArguments());
-        }
-}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialRelation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialRelation.java
index f884f8d6..9bae53a9 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialRelation.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialRelation.java
@@ -1,18 +1,16 @@
 package tools.refinery.store.reasoning.representation;
 
-import tools.refinery.store.reasoning.literal.Modality;
-import tools.refinery.store.reasoning.literal.PartialRelationLiteral;
-import tools.refinery.store.reasoning.literal.ModalRelationLiteral;
-import tools.refinery.store.query.RelationLike;
-import tools.refinery.store.query.Variable;
-import tools.refinery.store.query.literal.CallPolarity;
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.term.NodeSort;
+import tools.refinery.store.query.term.Sort;
 import tools.refinery.store.representation.AbstractDomain;
 import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.representation.TruthValueDomain;
 
+import java.util.Arrays;
 import java.util.List;
 
-public record PartialRelation(String name, int arity) implements PartialSymbol<TruthValue, Boolean>, RelationLike {
+public record PartialRelation(String name, int arity) implements PartialSymbol<TruthValue, Boolean>, Constraint {
         @Override
         public AbstractDomain<TruthValue, Boolean> abstractDomain() {
                 return TruthValueDomain.INSTANCE;
@@ -28,24 +26,16 @@ public record PartialRelation(String name, int arity) implements PartialSymbol<T
                 return false;
         }
 
-        public ModalRelationLiteral call(CallPolarity polarity, Modality modality, List<Variable> arguments) {
-                return new ModalRelationLiteral(polarity, modality, this, arguments);
-        }
-
-        public PartialRelationLiteral call(CallPolarity polarity, List<Variable> arguments) {
-                return new PartialRelationLiteral(polarity, this, arguments);
-        }
-
-        public PartialRelationLiteral call(CallPolarity polarity, Variable... arguments) {
-                return call(polarity, List.of(arguments));
-        }
-
-        public PartialRelationLiteral call(Variable... arguments) {
-                return call(CallPolarity.POSITIVE, arguments);
+        @Override
+        public List<Sort> getSorts() {
+                var sorts = new Sort[arity()];
+                Arrays.fill(sorts, NodeSort.INSTANCE);
+                return List.of(sorts);
         }
 
-        public PartialRelationLiteral callTransitive(Variable left, Variable right) {
-                return call(CallPolarity.TRANSITIVE, List.of(left, right));
+        @Override
+        public String toReferenceString() {
+                return name;
         }
 
         @Override
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RelationRefinementAction.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RelationRefinementAction.java
index c7681b53..e8ed05a3 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RelationRefinementAction.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RelationRefinementAction.java
@@ -3,7 +3,7 @@ package tools.refinery.store.reasoning.rule;
 import tools.refinery.store.reasoning.Reasoning;
 import tools.refinery.store.reasoning.representation.PartialRelation;
 import tools.refinery.store.model.Model;
-import tools.refinery.store.query.Variable;
+import tools.refinery.store.query.term.Variable;
 import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.tuple.Tuple;
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/Rule.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/Rule.java
index 8a812518..c7b16d47 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/Rule.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/Rule.java
@@ -1,7 +1,7 @@
 package tools.refinery.store.reasoning.rule;
 
 import tools.refinery.store.model.Model;
-import tools.refinery.store.query.Dnf;
+import tools.refinery.store.query.dnf.Dnf;
 
 import java.util.ArrayList;
 import java.util.HashSet;
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RuleAction.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RuleAction.java
index bf980759..4753b8bc 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RuleAction.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RuleAction.java
@@ -1,7 +1,7 @@
 package tools.refinery.store.reasoning.rule;
 
 import tools.refinery.store.model.Model;
-import tools.refinery.store.query.Variable;
+import tools.refinery.store.query.term.Variable;
 
 import java.util.List;
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java
index 042c2636..90633495 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.reasoning.translator;
+package tools.refinery.store.reasoning.seed;
 
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.tuple.Tuple;
@@ -6,7 +6,7 @@ import tools.refinery.store.tuple.Tuple;
 public interface Seed<T> {
         int arity();
 
-        T getReducedValue();
+        T reducedValue();
 
         T get(Tuple key);
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/UniformSeed.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/UniformSeed.java
new file mode 100644
index 00000000..a030f6ea
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/UniformSeed.java
@@ -0,0 +1,22 @@
+package tools.refinery.store.reasoning.seed;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.tuple.Tuple;
+
+public record UniformSeed<T>(int arity, T reducedValue) implements Seed<T> {
+        public UniformSeed {
+                if (arity < 0) {
+                        throw new IllegalArgumentException("Arity must not be negative");
+                }
+        }
+
+        @Override
+        public T get(Tuple key) {
+                return reducedValue;
+        }
+
+        @Override
+        public Cursor<Tuple, T> getCursor(T defaultValue, int nodeCount) {
+                return null;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/Advice.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/Advice.java
index 7909a7e1..5cdfedf7 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/Advice.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/Advice.java
@@ -2,7 +2,7 @@ package tools.refinery.store.reasoning.translator;
 
 import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
 import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.query.Variable;
+import tools.refinery.store.query.term.Variable;
 import tools.refinery.store.query.literal.Literal;
 import tools.refinery.store.query.substitution.Substitutions;
 
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslatedRelation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslatedRelation.java
new file mode 100644
index 00000000..9bab80c9
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslatedRelation.java
@@ -0,0 +1,22 @@
+package tools.refinery.store.reasoning.translator;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.literal.CallPolarity;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.reasoning.PartialInterpretation;
+import tools.refinery.store.reasoning.literal.Modality;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.TruthValue;
+
+import java.util.List;
+
+public interface TranslatedRelation {
+        PartialRelation getSource();
+
+        void configure(List<Advice> advices);
+
+        List<Literal> call(CallPolarity polarity, Modality modality, List<Variable> arguments);
+
+        PartialInterpretation<TruthValue, Boolean> createPartialInterpretation(Model model);
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationUnit.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationUnit.java
index e45d20c8..24b93911 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationUnit.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationUnit.java
@@ -1,48 +1,32 @@
 package tools.refinery.store.reasoning.translator;
 
-import tools.refinery.store.reasoning.ReasoningBuilder;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStoreBuilder;
-import tools.refinery.store.reasoning.AnyPartialInterpretation;
-import tools.refinery.store.reasoning.literal.Modality;
-import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
-import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.query.Variable;
-import tools.refinery.store.query.literal.CallPolarity;
-import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.reasoning.ReasoningBuilder;
 
 import java.util.Collection;
-import java.util.List;
-import java.util.Map;
 
 public abstract class TranslationUnit {
         private ReasoningBuilder reasoningBuilder;
 
-        protected ReasoningBuilder getPartialInterpretationBuilder() {
+        protected ReasoningBuilder getReasoningBuilder() {
                 return reasoningBuilder;
         }
 
         public void setPartialInterpretationBuilder(ReasoningBuilder reasoningBuilder) {
                 this.reasoningBuilder = reasoningBuilder;
+                configureReasoningBuilder();
         }
 
         protected ModelStoreBuilder getModelStoreBuilder() {
                 return reasoningBuilder.getStoreBuilder();
         }
 
-        public abstract Collection<AnyPartialSymbol> getTranslatedPartialSymbols();
-
-        public Collection<Advice> computeAdvices() {
-                // No advices to give by default.
-                return List.of();
+        protected void configureReasoningBuilder() {
+                // Nothing to configure by default.
         }
 
-        public abstract void configure(Collection<Advice> advices);
-
-        public abstract List<Literal> call(CallPolarity polarity, Modality modality, PartialRelation target,
-                                                                           List<Variable> arguments);
-
-        public abstract Map<AnyPartialSymbol, AnyPartialInterpretation> createPartialInterpretations(Model model);
+        public abstract Collection<TranslatedRelation> getTranslatedRelations();
 
         public abstract void initializeModel(Model model, int nodeCount);
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionInterpretation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionInterpretation.java
new file mode 100644
index 00000000..b703f142
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionInterpretation.java
@@ -0,0 +1,88 @@
+package tools.refinery.store.reasoning.translator.base;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.query.ResultSet;
+import tools.refinery.store.reasoning.MergeResult;
+import tools.refinery.store.reasoning.PartialInterpretation;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+public class BaseDecisionInterpretation implements PartialInterpretation<TruthValue, Boolean> {
+        private final ReasoningAdapter reasoningAdapter;
+        private PartialRelation partialRelation;
+        private final ResultSet<Boolean> mustResultSet;
+        private final ResultSet<Boolean> mayResultSet;
+        private final ResultSet<Boolean> errorResultSet;
+        private final ResultSet<Boolean> currentResultSet;
+        private final Interpretation<TruthValue> interpretation;
+
+        public BaseDecisionInterpretation(ReasoningAdapter reasoningAdapter, ResultSet<Boolean> mustResultSet,
+                                                                          ResultSet<Boolean> mayResultSet, ResultSet<Boolean> errorResultSet,
+                                                                          ResultSet<Boolean> currentResultSet, Interpretation<TruthValue> interpretation) {
+                this.reasoningAdapter = reasoningAdapter;
+                this.mustResultSet = mustResultSet;
+                this.mayResultSet = mayResultSet;
+                this.errorResultSet = errorResultSet;
+                this.currentResultSet = currentResultSet;
+                this.interpretation = interpretation;
+        }
+
+        @Override
+        public ReasoningAdapter getAdapter() {
+                return reasoningAdapter;
+        }
+
+        @Override
+        public int countUnfinished() {
+                return 0;
+        }
+
+        @Override
+        public int countErrors() {
+                return errorResultSet.size();
+        }
+
+        @Override
+        public PartialRelation getPartialSymbol() {
+                return partialRelation;
+        }
+
+        @Override
+        public TruthValue get(Tuple key) {
+                return null;
+        }
+
+        @Override
+        public Cursor<Tuple, TruthValue> getAll() {
+                return null;
+        }
+
+        @Override
+        public MergeResult merge(Tuple key, TruthValue value) {
+                TruthValue newValue;
+                switch (value) {
+                case UNKNOWN -> {
+                        return MergeResult.UNCHANGED;
+                }
+                case TRUE -> newValue = mayResultSet.get(key) ? TruthValue.TRUE : TruthValue.ERROR;
+                case FALSE -> newValue = mustResultSet.get(key) ? TruthValue.ERROR : TruthValue.FALSE;
+                case ERROR -> newValue = TruthValue.ERROR;
+                default -> throw new IllegalArgumentException("Unknown truth value: " + value);
+                }
+                var oldValue = interpretation.put(key, newValue);
+                return oldValue == TruthValue.ERROR ? MergeResult.UNCHANGED : MergeResult.REFINED;
+        }
+
+        @Override
+        public Boolean getConcrete(Tuple key) {
+                return currentResultSet.get(key);
+        }
+
+        @Override
+        public Cursor<Tuple, Boolean> getAllConcrete() {
+                return null;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionTranslationUnit.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionTranslationUnit.java
new file mode 100644
index 00000000..36e2782a
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionTranslationUnit.java
@@ -0,0 +1,49 @@
+package tools.refinery.store.reasoning.translator.base;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.seed.Seed;
+import tools.refinery.store.reasoning.seed.UniformSeed;
+import tools.refinery.store.reasoning.translator.TranslatedRelation;
+import tools.refinery.store.reasoning.translator.TranslationUnit;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+
+import java.util.Collection;
+import java.util.List;
+
+public class BaseDecisionTranslationUnit extends TranslationUnit {
+        private final PartialRelation partialRelation;
+        private final Seed<TruthValue> seed;
+        private final Symbol<TruthValue> symbol;
+
+        public BaseDecisionTranslationUnit(PartialRelation partialRelation, Seed<TruthValue> seed) {
+                if (seed.arity() != partialRelation.arity()) {
+                        throw new IllegalArgumentException("Expected seed with arity %d for %s, got arity %s"
+                                        .formatted(partialRelation.arity(), partialRelation, seed.arity()));
+                }
+                this.partialRelation = partialRelation;
+                this.seed = seed;
+                symbol = new Symbol<>(partialRelation.name(), partialRelation.arity(), TruthValue.class, TruthValue.UNKNOWN);
+        }
+
+        public BaseDecisionTranslationUnit(PartialRelation partialRelation) {
+                this(partialRelation, new UniformSeed<>(partialRelation.arity(), TruthValue.UNKNOWN));
+        }
+
+        @Override
+        protected void configureReasoningBuilder() {
+                getModelStoreBuilder().symbol(symbol);
+        }
+
+        @Override
+        public Collection<TranslatedRelation> getTranslatedRelations() {
+                return List.of(new TranslatedBaseDecision(getReasoningBuilder(), partialRelation, symbol));
+        }
+
+        @Override
+        public void initializeModel(Model model, int nodeCount) {
+                var interpretation = model.getInterpretation(symbol);
+                interpretation.putAll(seed.getCursor(TruthValue.UNKNOWN, nodeCount));
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/TranslatedBaseDecision.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/TranslatedBaseDecision.java
new file mode 100644
index 00000000..2294b4fd
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/TranslatedBaseDecision.java
@@ -0,0 +1,49 @@
+package tools.refinery.store.reasoning.translator.base;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.literal.CallPolarity;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.reasoning.PartialInterpretation;
+import tools.refinery.store.reasoning.ReasoningBuilder;
+import tools.refinery.store.reasoning.literal.Modality;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.Advice;
+import tools.refinery.store.reasoning.translator.TranslatedRelation;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+
+import java.util.List;
+
+class TranslatedBaseDecision implements TranslatedRelation {
+        private final ReasoningBuilder reasoningBuilder;
+        private final PartialRelation partialRelation;
+        private final Symbol<TruthValue> symbol;
+
+        public TranslatedBaseDecision(ReasoningBuilder reasoningBuilder, PartialRelation partialRelation,
+                                                                  Symbol<TruthValue> symbol) {
+                this.reasoningBuilder = reasoningBuilder;
+                this.partialRelation = partialRelation;
+                this.symbol = symbol;
+        }
+
+        @Override
+        public PartialRelation getSource() {
+                return partialRelation;
+        }
+
+        @Override
+        public void configure(List<Advice> advices) {
+
+        }
+
+        @Override
+        public List<Literal> call(CallPolarity polarity, Modality modality, List<Variable> arguments) {
+                return null;
+        }
+
+        @Override
+        public PartialInterpretation<TruthValue, Boolean> createPartialInterpretation(Model model) {
+                return null;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslationUnit.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslationUnit.java
index c800b4cd..4b0761f2 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslationUnit.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslationUnit.java
@@ -1,18 +1,14 @@
 package tools.refinery.store.reasoning.translator.typehierarchy;
 
-import tools.refinery.store.reasoning.AnyPartialInterpretation;
-import tools.refinery.store.reasoning.literal.Modality;
-import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+import tools.refinery.store.model.Model;
 import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.reasoning.translator.Advice;
+import tools.refinery.store.reasoning.translator.TranslatedRelation;
 import tools.refinery.store.reasoning.translator.TranslationUnit;
-import tools.refinery.store.model.Model;
-import tools.refinery.store.query.Variable;
-import tools.refinery.store.query.literal.CallPolarity;
-import tools.refinery.store.query.literal.Literal;
 import tools.refinery.store.representation.Symbol;
 
-import java.util.*;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
 
 public class TypeHierarchyTranslationUnit extends TranslationUnit {
         static final Symbol<InferredType> INFERRED_TYPE_SYMBOL = new Symbol<>("inferredType", 1,
@@ -25,24 +21,8 @@ public class TypeHierarchyTranslationUnit extends TranslationUnit {
         }
 
         @Override
-        public Collection<AnyPartialSymbol> getTranslatedPartialSymbols() {
-                return null;
-        }
-
-        @Override
-        public void configure(Collection<Advice> advices) {
-
-        }
-
-        @Override
-        public List<Literal> call(CallPolarity polarity, Modality modality, PartialRelation target,
-                                                          List<Variable> arguments) {
-                return null;
-        }
-
-        @Override
-        public Map<AnyPartialSymbol, AnyPartialInterpretation> createPartialInterpretations(Model model) {
-                return null;
+        public Collection<TranslatedRelation> getTranslatedRelations() {
+                return List.of();
         }
 
         @Override