155 files changed, 7679 insertions, 0 deletions

diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/Constraint.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/Constraint.java
new file mode 100644
index 00000000..916fb35c
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/Constraint.java
@@ -0,0 +1,72 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.literal.*;
+import tools.refinery.store.query.term.*;
+
+import java.util.List;
+
+public interface Constraint {
+        String name();
+
+        List<Parameter> getParameters();
+
+        default int arity() {
+                return getParameters().size();
+        }
+
+        default boolean invalidIndex(int i) {
+                return i < 0 || i >= arity();
+        }
+
+        default Reduction getReduction() {
+                return Reduction.NOT_REDUCIBLE;
+        }
+
+        default boolean equals(LiteralEqualityHelper helper, Constraint other) {
+                return equals(other);
+        }
+
+        default String toReferenceString() {
+                return name();
+        }
+
+        default CallLiteral call(CallPolarity polarity, List<Variable> arguments) {
+                return new CallLiteral(polarity, this, arguments);
+        }
+
+        default CallLiteral call(CallPolarity polarity, Variable... arguments) {
+                return call(polarity, List.of(arguments));
+        }
+
+        default CallLiteral call(Variable... arguments) {
+                return call(CallPolarity.POSITIVE, arguments);
+        }
+
+        default CallLiteral callTransitive(NodeVariable left, NodeVariable right) {
+                return call(CallPolarity.TRANSITIVE, List.of(left, right));
+        }
+
+        default AssignedValue<Integer> count(List<Variable> arguments) {
+                return targetVariable -> new CountLiteral(targetVariable, this, arguments);
+        }
+
+        default AssignedValue<Integer> count(Variable... arguments) {
+                return count(List.of(arguments));
+        }
+
+        default <R, T> AssignedValue<R> aggregateBy(DataVariable<T> inputVariable, Aggregator<R, T> aggregator,
+                                                                                                List<Variable> arguments) {
+                return targetVariable -> new AggregationLiteral<>(targetVariable, aggregator, inputVariable, this, arguments);
+        }
+
+        default <R, T> AssignedValue<R> aggregateBy(DataVariable<T> inputVariable, Aggregator<R, T> aggregator,
+                                                                                                Variable... arguments) {
+                return aggregateBy(inputVariable, aggregator, List.of(arguments));
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryAdapter.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryAdapter.java
new file mode 100644
index 00000000..1fa96a07
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryAdapter.java
@@ -0,0 +1,26 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query;
+
+import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.query.dnf.AnyQuery;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.resultset.AnyResultSet;
+import tools.refinery.store.query.resultset.ResultSet;
+
+public interface ModelQueryAdapter extends ModelAdapter {
+        ModelQueryStoreAdapter getStoreAdapter();
+
+        default AnyResultSet getResultSet(AnyQuery query) {
+                return getResultSet((Query<?>) query);
+        }
+
+        <T> ResultSet<T> getResultSet(Query<T> query);
+
+        boolean hasPendingChanges();
+
+        void flushChanges();
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryBuilder.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryBuilder.java
new file mode 100644
index 00000000..c62a95b5
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryBuilder.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query;
+
+import tools.refinery.store.adapter.ModelAdapterBuilder;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.dnf.AnyQuery;
+
+import java.util.Collection;
+import java.util.List;
+
+@SuppressWarnings("UnusedReturnValue")
+public interface ModelQueryBuilder extends ModelAdapterBuilder {
+        default ModelQueryBuilder queries(AnyQuery... queries) {
+                return queries(List.of(queries));
+        }
+
+        default ModelQueryBuilder queries(Collection<? extends AnyQuery> queries) {
+                queries.forEach(this::query);
+                return this;
+        }
+
+        ModelQueryBuilder query(AnyQuery query);
+
+        @Override
+        ModelQueryStoreAdapter build(ModelStore store);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryStoreAdapter.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryStoreAdapter.java
new file mode 100644
index 00000000..f0a950a6
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryStoreAdapter.java
@@ -0,0 +1,22 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query;
+
+import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.dnf.AnyQuery;
+import tools.refinery.store.query.view.AnySymbolView;
+
+import java.util.Collection;
+
+public interface ModelQueryStoreAdapter extends ModelStoreAdapter {
+        Collection<AnySymbolView> getSymbolViews();
+
+        Collection<AnyQuery> getQueries();
+
+        @Override
+        ModelQueryAdapter createModelAdapter(Model model);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/AbstractQueryBuilder.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/AbstractQueryBuilder.java
new file mode 100644
index 00000000..2a3e3ce0
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/AbstractQueryBuilder.java
@@ -0,0 +1,175 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.dnf.callback.*;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.query.term.ParameterDirection;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+public abstract class AbstractQueryBuilder<T extends AbstractQueryBuilder<T>> {
+        protected final DnfBuilder dnfBuilder;
+
+        protected AbstractQueryBuilder(DnfBuilder dnfBuilder) {
+                this.dnfBuilder = dnfBuilder;
+        }
+
+        protected abstract T self();
+
+        public NodeVariable parameter() {
+                return dnfBuilder.parameter();
+        }
+
+        public NodeVariable parameter(String name) {
+                return dnfBuilder.parameter(name);
+        }
+
+        public NodeVariable parameter(ParameterDirection direction) {
+                return dnfBuilder.parameter(direction);
+        }
+
+        public NodeVariable parameter(String name, ParameterDirection direction) {
+                return dnfBuilder.parameter(name, direction);
+        }
+
+        public T parameter(NodeVariable variable) {
+                dnfBuilder.parameter(variable);
+                return self();
+        }
+
+        public T parameter(NodeVariable variable, ParameterDirection direction) {
+                dnfBuilder.parameter(variable, direction);
+                return self();
+        }
+
+        public T parameters(NodeVariable... variables) {
+                dnfBuilder.parameters(variables);
+                return self();
+        }
+
+        public T parameters(List<NodeVariable> variables) {
+                dnfBuilder.parameters(variables);
+                return self();
+        }
+
+        public T parameters(List<NodeVariable> variables, ParameterDirection direction) {
+                dnfBuilder.parameters(variables, direction);
+                return self();
+        }
+
+        public T symbolicParameters(List<SymbolicParameter> parameters) {
+                dnfBuilder.symbolicParameters(parameters);
+                return self();
+        }
+
+        public T functionalDependencies(Collection<FunctionalDependency<Variable>> functionalDependencies) {
+                dnfBuilder.functionalDependencies(functionalDependencies);
+                return self();
+        }
+
+        public T functionalDependency(FunctionalDependency<Variable> functionalDependency) {
+                dnfBuilder.functionalDependency(functionalDependency);
+                return self();
+        }
+
+        public T functionalDependency(Set<? extends Variable> forEach, Set<? extends Variable> unique) {
+                dnfBuilder.functionalDependency(forEach, unique);
+                return self();
+        }
+
+        public T clause(ClauseCallback0 callback) {
+                dnfBuilder.clause(callback);
+                return self();
+        }
+
+        public T clause(ClauseCallback1Data0 callback) {
+                dnfBuilder.clause(callback);
+                return self();
+        }
+
+        public <U1> T clause(Class<U1> type1, ClauseCallback1Data1<U1> callback) {
+                dnfBuilder.clause(type1, callback);
+                return self();
+        }
+
+        public T clause(ClauseCallback2Data0 callback) {
+                dnfBuilder.clause(callback);
+                return self();
+        }
+
+        public <U1> T clause(Class<U1> type1, ClauseCallback2Data1<U1> callback) {
+                dnfBuilder.clause(type1, callback);
+                return self();
+        }
+
+        public <U1, U2> T clause(Class<U1> type1, Class<U2> type2, ClauseCallback2Data2<U1, U2> callback) {
+                dnfBuilder.clause(type1, type2, callback);
+                return self();
+        }
+
+        public T clause(ClauseCallback3Data0 callback) {
+                dnfBuilder.clause(callback);
+                return self();
+        }
+
+        public <U1> T clause(Class<U1> type1, ClauseCallback3Data1<U1> callback) {
+                dnfBuilder.clause(type1, callback);
+                return self();
+        }
+
+        public <U1, U2> T clause(Class<U1> type1, Class<U2> type2, ClauseCallback3Data2<U1, U2> callback) {
+                dnfBuilder.clause(type1, type2, callback);
+                return self();
+        }
+
+        public <U1, U2, U3> T clause(Class<U1> type1, Class<U2> type2, Class<U3> type3,
+                                                                 ClauseCallback3Data3<U1, U2, U3> callback) {
+                dnfBuilder.clause(type1, type2, type3, callback);
+                return self();
+        }
+
+        public T clause(ClauseCallback4Data0 callback) {
+                dnfBuilder.clause(callback);
+                return self();
+        }
+
+        public <U1> T clause(Class<U1> type1, ClauseCallback4Data1<U1> callback) {
+                dnfBuilder.clause(type1, callback);
+                return self();
+        }
+
+        public <U1, U2> T clause(Class<U1> type1, Class<U2> type2, ClauseCallback4Data2<U1, U2> callback) {
+                dnfBuilder.clause(type1, type2, callback);
+                return self();
+        }
+
+        public <U1, U2, U3> T clause(Class<U1> type1, Class<U2> type2, Class<U3> type3,
+                                                                 ClauseCallback4Data3<U1, U2, U3> callback) {
+                dnfBuilder.clause(type1, type2, type3, callback);
+                return self();
+        }
+
+        public <U1, U2, U3, U4> T clause(Class<U1> type1, Class<U2> type2, Class<U3> type3, Class<U4> type4,
+                                                                         ClauseCallback4Data4<U1, U2, U3, U4> callback) {
+                dnfBuilder.clause(type1, type2, type3, type4, callback);
+                return self();
+        }
+
+        public T clause(Literal... literals) {
+                dnfBuilder.clause(literals);
+                return self();
+        }
+
+        public T clause(Collection<? extends Literal> literals) {
+                dnfBuilder.clause(literals);
+                return self();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/AnyQuery.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/AnyQuery.java
new file mode 100644
index 00000000..5e28af68
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/AnyQuery.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+public sealed interface AnyQuery permits Query {
+        String name();
+
+        int arity();
+
+        Class<?> valueType();
+
+        Dnf getDnf();
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/ClausePostProcessor.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/ClausePostProcessor.java
new file mode 100644
index 00000000..b5e7092b
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/ClausePostProcessor.java
@@ -0,0 +1,324 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import org.jetbrains.annotations.NotNull;
+import tools.refinery.store.query.literal.BooleanLiteral;
+import tools.refinery.store.query.literal.EquivalenceLiteral;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.substitution.MapBasedSubstitution;
+import tools.refinery.store.query.substitution.StatelessSubstitution;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.query.term.ParameterDirection;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.*;
+import java.util.function.Function;
+
+class ClausePostProcessor {
+        private final Map<Variable, ParameterInfo> parameters;
+        private final List<Literal> literals;
+        private final Map<NodeVariable, NodeVariable> representatives = new LinkedHashMap<>();
+        private final Map<NodeVariable, Set<NodeVariable>> equivalencePartition = new HashMap<>();
+        private List<Literal> substitutedLiterals;
+        private final Set<Variable> existentiallyQuantifiedVariables = new LinkedHashSet<>();
+        private Set<Variable> positiveVariables;
+        private Map<Variable, Set<SortableLiteral>> variableToLiteralInputMap;
+        private PriorityQueue<SortableLiteral> literalsWithAllInputsBound;
+        private LinkedHashSet<Literal> topologicallySortedLiterals;
+
+        public ClausePostProcessor(Map<Variable, ParameterInfo> parameters, List<Literal> literals) {
+                this.parameters = parameters;
+                this.literals = literals;
+        }
+
+        public Result postProcessClause() {
+                mergeEquivalentNodeVariables();
+                substitutedLiterals = new ArrayList<>(literals.size());
+                keepParameterEquivalences();
+                substituteLiterals();
+                computeExistentiallyQuantifiedVariables();
+                computePositiveVariables();
+                validatePositiveRepresentatives();
+                validatePrivateVariables();
+                topologicallySortLiterals();
+                var filteredLiterals = new ArrayList<Literal>(topologicallySortedLiterals.size());
+                for (var literal : topologicallySortedLiterals) {
+                        var reducedLiteral = literal.reduce();
+                        if (BooleanLiteral.FALSE.equals(reducedLiteral)) {
+                                return ConstantResult.ALWAYS_FALSE;
+                        } else if (!BooleanLiteral.TRUE.equals(reducedLiteral)) {
+                                filteredLiterals.add(reducedLiteral);
+                        }
+                }
+                if (filteredLiterals.isEmpty()) {
+                        return ConstantResult.ALWAYS_TRUE;
+                }
+                var clause = new DnfClause(Collections.unmodifiableSet(positiveVariables),
+                                Collections.unmodifiableList(filteredLiterals));
+                return new ClauseResult(clause);
+        }
+
+        private void mergeEquivalentNodeVariables() {
+                for (var literal : literals) {
+                        if (isPositiveEquivalence(literal)) {
+                                var equivalenceLiteral = (EquivalenceLiteral) literal;
+                                mergeVariables(equivalenceLiteral.left(), equivalenceLiteral.right());
+                        }
+                }
+        }
+
+        private static boolean isPositiveEquivalence(Literal literal) {
+                return literal instanceof EquivalenceLiteral equivalenceLiteral && equivalenceLiteral.positive();
+        }
+
+        private void mergeVariables(NodeVariable left, NodeVariable right) {
+                var leftRepresentative = getRepresentative(left);
+                var rightRepresentative = getRepresentative(right);
+                var leftInfo = parameters.get(leftRepresentative);
+                var rightInfo = parameters.get(rightRepresentative);
+                if (leftInfo != null && (rightInfo == null || leftInfo.index() <= rightInfo.index())) {
+                        // Prefer the variable occurring earlier in the parameter list as a representative.
+                        doMergeVariables(leftRepresentative, rightRepresentative);
+                } else {
+                        doMergeVariables(rightRepresentative, leftRepresentative);
+                }
+        }
+
+        private void doMergeVariables(NodeVariable parentRepresentative, NodeVariable newChildRepresentative) {
+                var parentSet = getEquivalentVariables(parentRepresentative);
+                var childSet = getEquivalentVariables(newChildRepresentative);
+                parentSet.addAll(childSet);
+                equivalencePartition.remove(newChildRepresentative);
+                for (var childEquivalentNodeVariable : childSet) {
+                        representatives.put(childEquivalentNodeVariable, parentRepresentative);
+                }
+        }
+
+        private NodeVariable getRepresentative(NodeVariable variable) {
+                return representatives.computeIfAbsent(variable, Function.identity());
+        }
+
+        private Set<NodeVariable> getEquivalentVariables(NodeVariable variable) {
+                var representative = getRepresentative(variable);
+                if (!representative.equals(variable)) {
+                        throw new AssertionError("NodeVariable %s already has a representative %s"
+                                        .formatted(variable, representative));
+                }
+                return equivalencePartition.computeIfAbsent(variable, key -> {
+                        var set = new HashSet<NodeVariable>(1);
+                        set.add(key);
+                        return set;
+                });
+        }
+
+        private void keepParameterEquivalences() {
+                for (var pair : representatives.entrySet()) {
+                        var left = pair.getKey();
+                        var right = pair.getValue();
+                        if (!left.equals(right) && parameters.containsKey(left) && parameters.containsKey(right)) {
+                                substitutedLiterals.add(left.isEquivalent(right));
+                        }
+                }
+        }
+
+        private void substituteLiterals() {
+                Substitution substitution;
+                if (representatives.isEmpty()) {
+                        substitution = null;
+                } else {
+                        substitution = new MapBasedSubstitution(Collections.unmodifiableMap(representatives),
+                                        StatelessSubstitution.IDENTITY);
+                }
+                for (var literal : literals) {
+                        if (isPositiveEquivalence(literal)) {
+                                // We already retained all equivalences that cannot be replaced with substitutions in
+                                // {@link#keepParameterEquivalences()}.
+                                continue;
+                        }
+                        var substitutedLiteral = substitution == null ? literal : literal.substitute(substitution);
+                        substitutedLiterals.add(substitutedLiteral);
+                }
+        }
+
+        private void computeExistentiallyQuantifiedVariables() {
+                for (var literal : substitutedLiterals) {
+                        for (var variable : literal.getOutputVariables()) {
+                                boolean added = existentiallyQuantifiedVariables.add(variable);
+                                if (!variable.isUnifiable()) {
+                                        var parameterInfo = parameters.get(variable);
+                                        if (parameterInfo != null && parameterInfo.direction() == ParameterDirection.IN) {
+                                                throw new IllegalArgumentException("Trying to bind %s parameter %s"
+                                                                .formatted(ParameterDirection.IN, variable));
+                                        }
+                                        if (!added) {
+                                                throw new IllegalArgumentException("Variable %s has multiple assigned values"
+                                                                .formatted(variable));
+                                        }
+                                }
+                        }
+                }
+        }
+
+        private void computePositiveVariables() {
+                positiveVariables = new LinkedHashSet<>();
+                for (var pair : parameters.entrySet()) {
+                        var variable = pair.getKey();
+                        if (pair.getValue().direction() == ParameterDirection.IN) {
+                                // Inputs count as positive, because they are already bound when we evaluate literals.
+                                positiveVariables.add(variable);
+                        } else if (!existentiallyQuantifiedVariables.contains(variable)) {
+                                throw new IllegalArgumentException("Unbound %s parameter %s"
+                                                .formatted(ParameterDirection.OUT, variable));
+                        }
+                }
+                positiveVariables.addAll(existentiallyQuantifiedVariables);
+        }
+
+        private void validatePositiveRepresentatives() {
+                for (var pair : equivalencePartition.entrySet()) {
+                        var representative = pair.getKey();
+                        if (!positiveVariables.contains(representative)) {
+                                var variableSet = pair.getValue();
+                                throw new IllegalArgumentException("Variables %s were merged by equivalence but are not bound"
+                                                .formatted(variableSet));
+                        }
+                }
+        }
+
+        private void validatePrivateVariables() {
+                var negativeVariablesMap = new HashMap<Variable, Literal>();
+                for (var literal : substitutedLiterals) {
+                        for (var variable : literal.getPrivateVariables(positiveVariables)) {
+                                var oldLiteral = negativeVariablesMap.put(variable, literal);
+                                if (oldLiteral != null) {
+                                        throw new IllegalArgumentException("Unbound variable %s appears in multiple literals %s and %s"
+                                                        .formatted(variable, oldLiteral, literal));
+                                }
+                        }
+                }
+        }
+
+        private void topologicallySortLiterals() {
+                topologicallySortedLiterals = new LinkedHashSet<>(substitutedLiterals.size());
+                variableToLiteralInputMap = new HashMap<>();
+                literalsWithAllInputsBound = new PriorityQueue<>();
+                int size = substitutedLiterals.size();
+                for (int i = 0; i < size; i++) {
+                        var literal = substitutedLiterals.get(i);
+                        var sortableLiteral = new SortableLiteral(i, literal);
+                        sortableLiteral.enqueue();
+                }
+                while (!literalsWithAllInputsBound.isEmpty()) {
+                        var variable = literalsWithAllInputsBound.remove();
+                        variable.addToSortedLiterals();
+                }
+                if (!variableToLiteralInputMap.isEmpty()) {
+                        throw new IllegalArgumentException("Unbound input variables %s"
+                                        .formatted(variableToLiteralInputMap.keySet()));
+                }
+        }
+
+        private class SortableLiteral implements Comparable<SortableLiteral> {
+                private final int index;
+                private final Literal literal;
+                private final Set<Variable> remainingInputs;
+
+                private SortableLiteral(int index, Literal literal) {
+                        this.index = index;
+                        this.literal = literal;
+                        remainingInputs = new HashSet<>(literal.getInputVariables(positiveVariables));
+                        for (var pair : parameters.entrySet()) {
+                                if (pair.getValue().direction() == ParameterDirection.IN) {
+                                        remainingInputs.remove(pair.getKey());
+                                }
+                        }
+                }
+
+                public void enqueue() {
+                        if (allInputsBound()) {
+                                addToAllInputsBoundQueue();
+                        } else {
+                                addToVariableToLiteralInputMap();
+                        }
+                }
+
+                private void bindVariable(Variable input) {
+                        if (!remainingInputs.remove(input)) {
+                                throw new AssertionError("Already processed input %s of literal %s".formatted(input, literal));
+                        }
+                        if (allInputsBound()) {
+                                addToAllInputsBoundQueue();
+                        }
+                }
+
+                private boolean allInputsBound() {
+                        return remainingInputs.isEmpty();
+                }
+
+                private void addToVariableToLiteralInputMap() {
+                        for (var inputVariable : remainingInputs) {
+                                var literalSetForInput = variableToLiteralInputMap.computeIfAbsent(
+                                                inputVariable, key -> new HashSet<>());
+                                literalSetForInput.add(this);
+                        }
+                }
+
+                private void addToAllInputsBoundQueue() {
+                        literalsWithAllInputsBound.add(this);
+                }
+
+                public void addToSortedLiterals() {
+                        if (!allInputsBound()) {
+                                throw new AssertionError("Inputs %s of %s are not yet bound".formatted(remainingInputs, literal));
+                        }
+                        // Add literal if we haven't yet added a duplicate of this literal.
+                        topologicallySortedLiterals.add(literal);
+                        for (var variable : literal.getOutputVariables()) {
+                                var literalSetForInput = variableToLiteralInputMap.remove(variable);
+                                if (literalSetForInput == null) {
+                                        continue;
+                                }
+                                for (var targetSortableLiteral : literalSetForInput) {
+                                        targetSortableLiteral.bindVariable(variable);
+                                }
+                        }
+                }
+
+                @Override
+                public int compareTo(@NotNull ClausePostProcessor.SortableLiteral other) {
+                        return Integer.compare(index, other.index);
+                }
+
+                @Override
+                public boolean equals(Object o) {
+                        if (this == o) return true;
+                        if (o == null || getClass() != o.getClass()) return false;
+                        SortableLiteral that = (SortableLiteral) o;
+                        return index == that.index && Objects.equals(literal, that.literal);
+                }
+
+                @Override
+                public int hashCode() {
+                        return Objects.hash(index, literal);
+                }
+        }
+
+        public sealed interface Result permits ClauseResult, ConstantResult {
+        }
+
+        public record ClauseResult(DnfClause clause) implements Result {
+        }
+
+        public enum ConstantResult implements Result {
+                ALWAYS_TRUE,
+                ALWAYS_FALSE
+        }
+
+        public record ParameterInfo(ParameterDirection direction, int index) {
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Dnf.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Dnf.java
new file mode 100644
index 00000000..50b245f7
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Dnf.java
@@ -0,0 +1,213 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.literal.Reduction;
+import tools.refinery.store.query.equality.DnfEqualityChecker;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.term.Parameter;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+public final class Dnf implements Constraint {
+        private static final String INDENTATION = "    ";
+
+        private final String name;
+        private final String uniqueName;
+        private final List<SymbolicParameter> symbolicParameters;
+        private final List<FunctionalDependency<Variable>> functionalDependencies;
+        private final List<DnfClause> clauses;
+
+        Dnf(String name, List<SymbolicParameter> symbolicParameters,
+                List<FunctionalDependency<Variable>> functionalDependencies, List<DnfClause> clauses) {
+                validateFunctionalDependencies(symbolicParameters, functionalDependencies);
+                this.name = name;
+                this.uniqueName = DnfUtils.generateUniqueName(name);
+                this.symbolicParameters = symbolicParameters;
+                this.functionalDependencies = functionalDependencies;
+                this.clauses = clauses;
+        }
+
+        private static void validateFunctionalDependencies(
+                        Collection<SymbolicParameter> symbolicParameters,
+                        Collection<FunctionalDependency<Variable>> functionalDependencies) {
+                var parameterSet = symbolicParameters.stream().map(SymbolicParameter::getVariable).collect(Collectors.toSet());
+                for (var functionalDependency : functionalDependencies) {
+                        validateParameters(symbolicParameters, parameterSet, functionalDependency.forEach(), functionalDependency);
+                        validateParameters(symbolicParameters, parameterSet, functionalDependency.unique(), functionalDependency);
+                }
+        }
+
+        private static void validateParameters(Collection<SymbolicParameter> symbolicParameters,
+                                                                                   Set<Variable> parameterSet, Collection<Variable> toValidate,
+                                                                                   FunctionalDependency<Variable> functionalDependency) {
+                for (var variable : toValidate) {
+                        if (!parameterSet.contains(variable)) {
+                                throw new IllegalArgumentException(
+                                                "Variable %s of functional dependency %s does not appear in the parameter list %s"
+                                                                .formatted(variable, functionalDependency, symbolicParameters));
+                        }
+                }
+        }
+
+        @Override
+        public String name() {
+                return name == null ? uniqueName : name;
+        }
+
+        public boolean isExplicitlyNamed() {
+                return name == null;
+        }
+
+        public String getUniqueName() {
+                return uniqueName;
+        }
+
+        public List<SymbolicParameter> getSymbolicParameters() {
+                return symbolicParameters;
+        }
+
+        public List<Parameter> getParameters() {
+                return Collections.unmodifiableList(symbolicParameters);
+        }
+
+        public List<FunctionalDependency<Variable>> getFunctionalDependencies() {
+                return functionalDependencies;
+        }
+
+        @Override
+        public int arity() {
+                return symbolicParameters.size();
+        }
+
+        public List<DnfClause> getClauses() {
+                return clauses;
+        }
+
+        public RelationalQuery asRelation() {
+                return new RelationalQuery(this);
+        }
+
+        public <T> FunctionalQuery<T> asFunction(Class<T> type) {
+                return new FunctionalQuery<>(this, type);
+        }
+
+        @Override
+        public Reduction getReduction() {
+                if (clauses.isEmpty()) {
+                        return Reduction.ALWAYS_FALSE;
+                }
+                for (var clause : clauses) {
+                        if (clause.literals().isEmpty()) {
+                                return Reduction.ALWAYS_TRUE;
+                        }
+                }
+                return Reduction.NOT_REDUCIBLE;
+        }
+
+        public boolean equalsWithSubstitution(DnfEqualityChecker callEqualityChecker, Dnf other) {
+                if (arity() != other.arity()) {
+                        return false;
+                }
+                for (int i = 0; i < arity(); i++) {
+                        if (!symbolicParameters.get(i).getDirection().equals(other.getSymbolicParameters().get(i).getDirection())) {
+                                return false;
+                        }
+                }
+                int numClauses = clauses.size();
+                if (numClauses != other.clauses.size()) {
+                        return false;
+                }
+                for (int i = 0; i < numClauses; i++) {
+                        var literalEqualityHelper = new LiteralEqualityHelper(callEqualityChecker, symbolicParameters,
+                                        other.symbolicParameters);
+                        if (!clauses.get(i).equalsWithSubstitution(literalEqualityHelper, other.clauses.get(i))) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+
+        @Override
+        public boolean equals(LiteralEqualityHelper helper, Constraint other) {
+                if (other instanceof Dnf otherDnf) {
+                        return helper.dnfEqual(this, otherDnf);
+                }
+                return false;
+        }
+
+        @Override
+        public String toString() {
+                return "%s/%d".formatted(name(), arity());
+        }
+
+        @Override
+        public String toReferenceString() {
+                return "@Dnf " + name();
+        }
+
+        public String toDefinitionString() {
+                var builder = new StringBuilder();
+                builder.append("pred ").append(name()).append("(");
+                var parameterIterator = symbolicParameters.iterator();
+                if (parameterIterator.hasNext()) {
+                        builder.append(parameterIterator.next());
+                        while (parameterIterator.hasNext()) {
+                                builder.append(", ").append(parameterIterator.next());
+                        }
+                }
+                builder.append(") <->");
+                var clauseIterator = clauses.iterator();
+                if (clauseIterator.hasNext()) {
+                        appendClause(clauseIterator.next(), builder);
+                        while (clauseIterator.hasNext()) {
+                                builder.append("\n;");
+                                appendClause(clauseIterator.next(), builder);
+                        }
+                } else {
+                        builder.append("\n").append(INDENTATION).append("<no clauses>");
+                }
+                builder.append(".\n");
+                return builder.toString();
+        }
+
+        private static void appendClause(DnfClause clause, StringBuilder builder) {
+                var iterator = clause.literals().iterator();
+                if (!iterator.hasNext()) {
+                        builder.append("\n").append(INDENTATION).append("<empty>");
+                        return;
+                }
+                builder.append("\n").append(INDENTATION).append(iterator.next());
+                while (iterator.hasNext()) {
+                        builder.append(",\n").append(INDENTATION).append(iterator.next());
+                }
+        }
+
+        public static DnfBuilder builder() {
+                return builder(null);
+        }
+
+        public static DnfBuilder builder(String name) {
+                return new DnfBuilder(name);
+        }
+
+        public static Dnf of(Consumer<DnfBuilder> callback) {
+                return of(null, callback);
+        }
+
+        public static Dnf of(String name, Consumer<DnfBuilder> callback) {
+                var builder = builder(name);
+                callback.accept(builder);
+                return builder.build();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfBuilder.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfBuilder.java
new file mode 100644
index 00000000..8e38ca6b
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfBuilder.java
@@ -0,0 +1,262 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.dnf.callback.*;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.query.term.ParameterDirection;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.*;
+
+@SuppressWarnings("UnusedReturnValue")
+public final class DnfBuilder {
+        private final String name;
+        private final Set<Variable> parameterVariables = new LinkedHashSet<>();
+        private final List<SymbolicParameter> parameters = new ArrayList<>();
+        private final List<FunctionalDependency<Variable>> functionalDependencies = new ArrayList<>();
+        private final List<List<Literal>> clauses = new ArrayList<>();
+
+        DnfBuilder(String name) {
+                this.name = name;
+        }
+
+        public NodeVariable parameter() {
+                return parameter((String) null);
+        }
+
+        public NodeVariable parameter(String name) {
+                return parameter(name, ParameterDirection.OUT);
+        }
+
+        public NodeVariable parameter(ParameterDirection direction) {
+                return parameter((String) null, direction);
+        }
+
+        public NodeVariable parameter(String name, ParameterDirection direction) {
+                var variable = Variable.of(name);
+                parameter(variable, direction);
+                return variable;
+        }
+
+        public <T> DataVariable<T> parameter(Class<T> type) {
+                return parameter(null, type);
+        }
+
+        public <T> DataVariable<T> parameter(String name, Class<T> type) {
+                return parameter(name, type, ParameterDirection.OUT);
+        }
+
+        public <T> DataVariable<T> parameter(Class<T> type, ParameterDirection direction) {
+                return parameter(null, type, direction);
+        }
+
+        public <T> DataVariable<T> parameter(String name, Class<T> type, ParameterDirection direction) {
+                var variable = Variable.of(name, type);
+                parameter(variable, direction);
+                return variable;
+        }
+
+        public DnfBuilder parameter(Variable variable) {
+                return parameter(variable, ParameterDirection.OUT);
+        }
+
+        public DnfBuilder parameter(Variable variable, ParameterDirection direction) {
+                return symbolicParameter(new SymbolicParameter(variable, direction));
+        }
+
+        public DnfBuilder parameters(Variable... variables) {
+                return parameters(List.of(variables));
+        }
+
+        public DnfBuilder parameters(Collection<? extends Variable> variables) {
+                return parameters(variables, ParameterDirection.OUT);
+        }
+
+        public DnfBuilder parameters(Collection<? extends Variable> variables, ParameterDirection direction) {
+                for (var variable : variables) {
+                        parameter(variable, direction);
+                }
+                return this;
+        }
+
+        public DnfBuilder symbolicParameter(SymbolicParameter symbolicParameter) {
+                var variable = symbolicParameter.getVariable();
+                if (!parameterVariables.add(variable)) {
+                        throw new IllegalArgumentException("Variable %s is already on the parameter list %s"
+                                        .formatted(variable, parameters));
+                }
+                parameters.add(symbolicParameter);
+                return this;
+        }
+
+        public DnfBuilder symbolicParameters(SymbolicParameter... symbolicParameters) {
+                return symbolicParameters(List.of(symbolicParameters));
+        }
+
+        public DnfBuilder symbolicParameters(Collection<SymbolicParameter> symbolicParameters) {
+                for (var symbolicParameter : symbolicParameters) {
+                        symbolicParameter(symbolicParameter);
+                }
+                return this;
+        }
+
+        public DnfBuilder functionalDependencies(Collection<FunctionalDependency<Variable>> functionalDependencies) {
+                this.functionalDependencies.addAll(functionalDependencies);
+                return this;
+        }
+
+        public DnfBuilder functionalDependency(FunctionalDependency<Variable> functionalDependency) {
+                functionalDependencies.add(functionalDependency);
+                return this;
+        }
+
+        public DnfBuilder functionalDependency(Set<? extends Variable> forEach, Set<? extends Variable> unique) {
+                return functionalDependency(new FunctionalDependency<>(Set.copyOf(forEach), Set.copyOf(unique)));
+        }
+
+        public DnfBuilder clause(ClauseCallback0 callback) {
+                return clause(callback.toLiterals());
+        }
+
+        public DnfBuilder clause(ClauseCallback1Data0 callback) {
+                return clause(callback.toLiterals(Variable.of("v1")));
+        }
+
+        public <T> DnfBuilder clause(Class<T> type1, ClauseCallback1Data1<T> callback) {
+                return clause(callback.toLiterals(Variable.of("v1", type1)));
+        }
+
+        public DnfBuilder clause(ClauseCallback2Data0 callback) {
+                return clause(callback.toLiterals(Variable.of("v1"), Variable.of("v2")));
+        }
+
+        public <T> DnfBuilder clause(Class<T> type1, ClauseCallback2Data1<T> callback) {
+                return clause(callback.toLiterals(Variable.of("v1"), Variable.of("d1", type1)));
+        }
+
+        public <T1, T2> DnfBuilder clause(Class<T1> type1, Class<T2> type2, ClauseCallback2Data2<T1, T2> callback) {
+                return clause(callback.toLiterals(Variable.of("d1", type1), Variable.of("d2", type2)));
+        }
+
+        public DnfBuilder clause(ClauseCallback3Data0 callback) {
+                return clause(callback.toLiterals(Variable.of("v1"), Variable.of("v2"), Variable.of("v3")));
+        }
+
+        public <T> DnfBuilder clause(Class<T> type1, ClauseCallback3Data1<T> callback) {
+                return clause(callback.toLiterals(Variable.of("v1"), Variable.of("v2"), Variable.of("d1", type1)));
+        }
+
+        public <T1, T2> DnfBuilder clause(Class<T1> type1, Class<T2> type2, ClauseCallback3Data2<T1, T2> callback) {
+                return clause(callback.toLiterals(Variable.of("v1"), Variable.of("d1", type1), Variable.of("d2", type2)));
+        }
+
+        public <T1, T2, T3> DnfBuilder clause(Class<T1> type1, Class<T2> type2, Class<T3> type3,
+                                                                                  ClauseCallback3Data3<T1, T2, T3> callback) {
+                return clause(callback.toLiterals(Variable.of("d1", type1), Variable.of("d2", type2),
+                                Variable.of("d3", type3)));
+        }
+
+        public DnfBuilder clause(ClauseCallback4Data0 callback) {
+                return clause(callback.toLiterals(Variable.of("v1"), Variable.of("v2"), Variable.of("v3"), Variable.of("v4")));
+        }
+
+        public <T> DnfBuilder clause(Class<T> type1, ClauseCallback4Data1<T> callback) {
+                return clause(callback.toLiterals(Variable.of("v1"), Variable.of("v2"), Variable.of("v3"), Variable.of("d1",
+                                type1)));
+        }
+
+        public <T1, T2> DnfBuilder clause(Class<T1> type1, Class<T2> type2, ClauseCallback4Data2<T1, T2> callback) {
+                return clause(callback.toLiterals(Variable.of("v1"), Variable.of("v2"), Variable.of("d1", type1),
+                                Variable.of("d2", type2)));
+        }
+
+        public <T1, T2, T3> DnfBuilder clause(Class<T1> type1, Class<T2> type2, Class<T3> type3,
+                                                                                  ClauseCallback4Data3<T1, T2, T3> callback) {
+                return clause(callback.toLiterals(Variable.of("v1"), Variable.of("d1", type1), Variable.of("d2", type2),
+                                Variable.of("d3", type3)));
+        }
+
+        public <T1, T2, T3, T4> DnfBuilder clause(Class<T1> type1, Class<T2> type2, Class<T3> type3, Class<T4> type4,
+                                                                                          ClauseCallback4Data4<T1, T2, T3, T4> callback) {
+                return clause(callback.toLiterals(Variable.of("d1", type1), Variable.of("d2", type2),
+                                Variable.of("d3", type3), Variable.of("d4", type4)));
+        }
+
+        public DnfBuilder clause(Literal... literals) {
+                clause(List.of(literals));
+                return this;
+        }
+
+        public DnfBuilder clause(Collection<? extends Literal> literals) {
+                clauses.add(List.copyOf(literals));
+                return this;
+        }
+
+        <T> void output(DataVariable<T> outputVariable) {
+                // Copy parameter variables to exclude the newly added {@code outputVariable}.
+                var fromParameters = Set.copyOf(parameterVariables);
+                parameter(outputVariable, ParameterDirection.OUT);
+                functionalDependency(fromParameters, Set.of(outputVariable));
+        }
+
+        public Dnf build() {
+                var postProcessedClauses = postProcessClauses();
+                return new Dnf(name, Collections.unmodifiableList(parameters),
+                                Collections.unmodifiableList(functionalDependencies),
+                                Collections.unmodifiableList(postProcessedClauses));
+        }
+
+        private List<DnfClause> postProcessClauses() {
+                var parameterInfoMap = getParameterInfoMap();
+                var postProcessedClauses = new ArrayList<DnfClause>(clauses.size());
+                for (var literals : clauses) {
+                        var postProcessor = new ClausePostProcessor(parameterInfoMap, literals);
+                        var result = postProcessor.postProcessClause();
+                        if (result instanceof ClausePostProcessor.ClauseResult clauseResult) {
+                                postProcessedClauses.add(clauseResult.clause());
+                        } else if (result instanceof ClausePostProcessor.ConstantResult constantResult) {
+                                switch (constantResult) {
+                                case ALWAYS_TRUE -> {
+                                        var inputVariables = getInputVariables();
+                                        return List.of(new DnfClause(inputVariables, List.of()));
+                                }
+                                case ALWAYS_FALSE -> {
+                                        // Skip this clause because it can never match.
+                                }
+                                default -> throw new IllegalStateException("Unexpected ClausePostProcessor.ConstantResult: " +
+                                                constantResult);
+                                }
+                        } else {
+                                throw new IllegalStateException("Unexpected ClausePostProcessor.Result: " + result);
+                        }
+                }
+                return postProcessedClauses;
+        }
+
+        private Map<Variable, ClausePostProcessor.ParameterInfo> getParameterInfoMap() {
+                var mutableParameterInfoMap = new LinkedHashMap<Variable, ClausePostProcessor.ParameterInfo>();
+                int arity = parameters.size();
+                for (int i = 0; i < arity; i++) {
+                        var parameter = parameters.get(i);
+                        mutableParameterInfoMap.put(parameter.getVariable(),
+                                        new ClausePostProcessor.ParameterInfo(parameter.getDirection(), i));
+                }
+                return Collections.unmodifiableMap(mutableParameterInfoMap);
+        }
+
+        private Set<Variable> getInputVariables() {
+                var inputParameters = new LinkedHashSet<Variable>();
+                for (var parameter : parameters) {
+                        if (parameter.getDirection() == ParameterDirection.IN) {
+                                inputParameters.add(parameter.getVariable());
+                        }
+                }
+                return Collections.unmodifiableSet(inputParameters);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfClause.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfClause.java
new file mode 100644
index 00000000..fdd0d47c
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfClause.java
@@ -0,0 +1,28 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.List;
+import java.util.Set;
+
+public record DnfClause(Set<Variable> positiveVariables, List<Literal> literals) {
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, DnfClause other) {
+                int size = literals.size();
+                if (size != other.literals.size()) {
+                        return false;
+                }
+                for (int i = 0; i < size; i++) {
+                        if (!literals.get(i).equalsWithSubstitution(helper, other.literals.get(i))) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfUtils.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfUtils.java
new file mode 100644
index 00000000..65ab3634
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfUtils.java
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import java.util.UUID;
+
+public final class DnfUtils {
+        private DnfUtils() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static String generateUniqueName(String originalName) {
+                UUID uuid = UUID.randomUUID();
+                String uniqueString = "_" + uuid.toString().replace('-', '_');
+                if (originalName == null) {
+                        return uniqueString;
+                } else {
+                        return originalName + uniqueString;
+                }
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalDependency.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalDependency.java
new file mode 100644
index 00000000..b00b2cb7
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalDependency.java
@@ -0,0 +1,20 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public record FunctionalDependency<T>(Set<T> forEach, Set<T> unique) {
+        public FunctionalDependency {
+                var uniqueForEach = new HashSet<>(unique);
+                uniqueForEach.retainAll(forEach);
+                if (!uniqueForEach.isEmpty()) {
+                        throw new IllegalArgumentException("Variables %s appear on both sides of the functional dependency"
+                                        .formatted(uniqueForEach));
+                }
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQuery.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQuery.java
new file mode 100644
index 00000000..5a32b1ba
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQuery.java
@@ -0,0 +1,99 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.literal.CallPolarity;
+import tools.refinery.store.query.term.Aggregator;
+import tools.refinery.store.query.term.AssignedValue;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public final class FunctionalQuery<T> extends Query<T> {
+        private final Class<T> type;
+
+        FunctionalQuery(Dnf dnf, Class<T> type) {
+                super(dnf);
+                var parameters = dnf.getSymbolicParameters();
+                int outputIndex = dnf.arity() - 1;
+                for (int i = 0; i < outputIndex; i++) {
+                        var parameter = parameters.get(i);
+                        var parameterType = parameter.tryGetType();
+                        if (parameterType.isPresent()) {
+                                throw new IllegalArgumentException("Expected parameter %s of %s to be a node variable, got %s instead"
+                                                .formatted(parameter, dnf, parameterType.get().getName()));
+                        }
+                }
+                var outputParameter = parameters.get(outputIndex);
+                var outputParameterType = outputParameter.tryGetType();
+                if (outputParameterType.isEmpty() || !outputParameterType.get().equals(type)) {
+                        throw new IllegalArgumentException("Expected parameter %s of %s to be %s, but got %s instead".formatted(
+                                        outputParameter, dnf, type, outputParameterType.map(Class::getName).orElse("node")));
+                }
+                this.type = type;
+        }
+
+        @Override
+        public int arity() {
+                return getDnf().arity() - 1;
+        }
+
+        @Override
+        public Class<T> valueType() {
+                return type;
+        }
+
+        @Override
+        public T defaultValue() {
+                return null;
+        }
+
+        public AssignedValue<T> call(List<NodeVariable> arguments) {
+                return targetVariable -> {
+                        var argumentsWithTarget = new ArrayList<Variable>(arguments.size() + 1);
+                        argumentsWithTarget.addAll(arguments);
+                        argumentsWithTarget.add(targetVariable);
+                        return getDnf().call(CallPolarity.POSITIVE, argumentsWithTarget);
+                };
+        }
+
+        public AssignedValue<T> call(NodeVariable... arguments) {
+                return call(List.of(arguments));
+        }
+
+        public <R> AssignedValue<R> aggregate(Aggregator<R, T> aggregator, List<NodeVariable> arguments) {
+                return targetVariable -> {
+                        var placeholderVariable = Variable.of(type);
+                        var argumentsWithPlaceholder = new ArrayList<Variable>(arguments.size() + 1);
+                        argumentsWithPlaceholder.addAll(arguments);
+                        argumentsWithPlaceholder.add(placeholderVariable);
+                        return getDnf()
+                                        .aggregateBy(placeholderVariable, aggregator, argumentsWithPlaceholder)
+                                        .toLiteral(targetVariable);
+                };
+        }
+
+        public <R> AssignedValue<R> aggregate(Aggregator<R, T> aggregator, NodeVariable... arguments) {
+                return aggregate(aggregator, List.of(arguments));
+        }
+
+        @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;
+                FunctionalQuery<?> that = (FunctionalQuery<?>) o;
+                return Objects.equals(type, that.type);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), type);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQueryBuilder.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQueryBuilder.java
new file mode 100644
index 00000000..d1cd7ba8
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQueryBuilder.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.term.DataVariable;
+
+public final class FunctionalQueryBuilder<T> extends AbstractQueryBuilder<FunctionalQueryBuilder<T>> {
+        private final DataVariable<T> outputVariable;
+        private final Class<T> type;
+
+        FunctionalQueryBuilder(DataVariable<T> outputVariable, DnfBuilder dnfBuilder, Class<T> type) {
+                super(dnfBuilder);
+                this.outputVariable = outputVariable;
+                this.type = type;
+        }
+
+        @Override
+        protected FunctionalQueryBuilder<T> self() {
+                return this;
+        }
+
+        public FunctionalQuery<T> build() {
+                dnfBuilder.output(outputVariable);
+                return dnfBuilder.build().asFunction(type);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Query.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Query.java
new file mode 100644
index 00000000..aaa52ce6
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Query.java
@@ -0,0 +1,179 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.dnf.callback.*;
+import tools.refinery.store.query.term.ParameterDirection;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Objects;
+
+public abstract sealed class Query<T> implements AnyQuery permits FunctionalQuery, RelationalQuery {
+        private static final String OUTPUT_VARIABLE_NAME = "output";
+
+        private final Dnf dnf;
+
+        protected Query(Dnf dnf) {
+                for (var parameter : dnf.getSymbolicParameters()) {
+                        if (parameter.getDirection() != ParameterDirection.OUT) {
+                                throw new IllegalArgumentException("Query parameter %s with direction %s is not allowed"
+                                                .formatted(parameter.getVariable(), parameter.getDirection()));
+                        }
+                }
+                this.dnf = dnf;
+        }
+
+        @Override
+        public String name() {
+                return dnf.name();
+        }
+
+        @Override
+        public Dnf getDnf() {
+                return dnf;
+        }
+
+        // Allow redeclaration of the method with refined return type.
+        @SuppressWarnings("squid:S3038")
+        @Override
+        public abstract Class<T> valueType();
+
+        public abstract T defaultValue();
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                Query<?> that = (Query<?>) o;
+                return Objects.equals(dnf, that.dnf);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(dnf);
+        }
+
+        @Override
+        public String toString() {
+                return dnf.toString();
+        }
+
+        public static QueryBuilder builder() {
+                return builder(null);
+        }
+
+        public static QueryBuilder builder(String name) {
+                return new QueryBuilder(name);
+        }
+
+        public static RelationalQuery of(QueryCallback0 callback) {
+                return of(null, callback);
+        }
+
+        public static RelationalQuery of(String name, QueryCallback0 callback) {
+                var builder = builder(name);
+                callback.accept(builder);
+                return builder.build();
+        }
+
+        public static RelationalQuery of(QueryCallback1 callback) {
+                return of(null, callback);
+        }
+
+        public static RelationalQuery of(String name, QueryCallback1 callback) {
+                var builder = builder(name);
+                callback.accept(builder, builder.parameter("p1"));
+                return builder.build();
+        }
+
+        public static RelationalQuery of(QueryCallback2 callback) {
+                return of(null, callback);
+        }
+
+        public static RelationalQuery of(String name, QueryCallback2 callback) {
+                var builder = builder(name);
+                callback.accept(builder, builder.parameter("p1"), builder.parameter("p2"));
+                return builder.build();
+        }
+
+        public static RelationalQuery of(QueryCallback3 callback) {
+                return of(null, callback);
+        }
+
+        public static RelationalQuery of(String name, QueryCallback3 callback) {
+                var builder = builder(name);
+                callback.accept(builder, builder.parameter("p1"), builder.parameter("p2"), builder.parameter("p3"));
+                return builder.build();
+        }
+
+        public static RelationalQuery of(QueryCallback4 callback) {
+                return of(null, callback);
+        }
+
+        public static RelationalQuery of(String name, QueryCallback4 callback) {
+                var builder = builder(name);
+                callback.accept(builder, builder.parameter("p1"), builder.parameter("p2"), builder.parameter("p3"),
+                                builder.parameter("p4"));
+                return builder.build();
+        }
+
+        public static <T> FunctionalQuery<T> of(Class<T> type, FunctionalQueryCallback0<T> callback) {
+                return of(null, type, callback);
+        }
+
+        public static <T> FunctionalQuery<T> of(String name, Class<T> type, FunctionalQueryCallback0<T> callback) {
+                var outputVariable = Variable.of(OUTPUT_VARIABLE_NAME, type);
+                var builder = builder(name).output(outputVariable);
+                callback.accept(builder, outputVariable);
+                return builder.build();
+        }
+
+        public static <T> FunctionalQuery<T> of(Class<T> type, FunctionalQueryCallback1<T> callback) {
+                return of(null, type, callback);
+        }
+
+        public static <T> FunctionalQuery<T> of(String name, Class<T> type, FunctionalQueryCallback1<T> callback) {
+                var outputVariable = Variable.of(OUTPUT_VARIABLE_NAME, type);
+                var builder = builder(name).output(outputVariable);
+                callback.accept(builder, builder.parameter("p1"), outputVariable);
+                return builder.build();
+        }
+
+        public static <T> FunctionalQuery<T> of(Class<T> type, FunctionalQueryCallback2<T> callback) {
+                return of(null, type, callback);
+        }
+
+        public static <T> FunctionalQuery<T> of(String name, Class<T> type, FunctionalQueryCallback2<T> callback) {
+                var outputVariable = Variable.of(OUTPUT_VARIABLE_NAME, type);
+                var builder = builder(name).output(outputVariable);
+                callback.accept(builder, builder.parameter("p1"), builder.parameter("p2"), outputVariable);
+                return builder.build();
+        }
+
+        public static <T> FunctionalQuery<T> of(Class<T> type, FunctionalQueryCallback3<T> callback) {
+                return of(null, type, callback);
+        }
+
+        public static <T> FunctionalQuery<T> of(String name, Class<T> type, FunctionalQueryCallback3<T> callback) {
+                var outputVariable = Variable.of(OUTPUT_VARIABLE_NAME, type);
+                var builder = builder(name).output(outputVariable);
+                callback.accept(builder, builder.parameter("p1"), builder.parameter("p2"), builder.parameter("p3"),
+                                outputVariable);
+                return builder.build();
+        }
+
+        public static <T> FunctionalQuery<T> of(Class<T> type, FunctionalQueryCallback4<T> callback) {
+                return of(null, type, callback);
+        }
+
+        public static <T> FunctionalQuery<T> of(String name, Class<T> type, FunctionalQueryCallback4<T> callback) {
+                var outputVariable = Variable.of(OUTPUT_VARIABLE_NAME, type);
+                var builder = builder(name).output(outputVariable);
+                callback.accept(builder, builder.parameter("p1"), builder.parameter("p2"), builder.parameter("p3"),
+                                builder.parameter("p4"), outputVariable);
+                return builder.build();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/QueryBuilder.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/QueryBuilder.java
new file mode 100644
index 00000000..138911bc
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/QueryBuilder.java
@@ -0,0 +1,27 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.term.DataVariable;
+
+public final class QueryBuilder extends AbstractQueryBuilder<QueryBuilder> {
+        QueryBuilder(String name) {
+                super(Dnf.builder(name));
+        }
+
+        @Override
+        protected QueryBuilder self() {
+                return this;
+        }
+
+        public <T> FunctionalQueryBuilder<T> output(DataVariable<T> outputVariable) {
+                return new FunctionalQueryBuilder<>(outputVariable, dnfBuilder, outputVariable.getType());
+        }
+
+        public RelationalQuery build() {
+                return dnfBuilder.build().asRelation();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/RelationalQuery.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/RelationalQuery.java
new file mode 100644
index 00000000..d34a7ace
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/RelationalQuery.java
@@ -0,0 +1,66 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.literal.CallLiteral;
+import tools.refinery.store.query.literal.CallPolarity;
+import tools.refinery.store.query.term.AssignedValue;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.Collections;
+import java.util.List;
+
+public final class RelationalQuery extends Query<Boolean> {
+        RelationalQuery(Dnf dnf) {
+                super(dnf);
+                for (var parameter : dnf.getSymbolicParameters()) {
+                        var parameterType = parameter.tryGetType();
+                        if (parameterType.isPresent()) {
+                                throw new IllegalArgumentException("Expected parameter %s of %s to be a node variable, got %s instead"
+                                                .formatted(parameter, dnf, parameterType.get().getName()));
+                        }
+                }
+        }
+
+        @Override
+        public int arity() {
+                return getDnf().arity();
+        }
+
+        @Override
+        public Class<Boolean> valueType() {
+                return Boolean.class;
+        }
+
+        @Override
+        public Boolean defaultValue() {
+                return false;
+        }
+
+        public CallLiteral call(CallPolarity polarity, List<NodeVariable> arguments) {
+                return getDnf().call(polarity, Collections.unmodifiableList(arguments));
+        }
+
+        public CallLiteral call(CallPolarity polarity, NodeVariable... arguments) {
+                return getDnf().call(polarity, arguments);
+        }
+
+        public CallLiteral call(NodeVariable... arguments) {
+                return getDnf().call(arguments);
+        }
+
+        public CallLiteral callTransitive(NodeVariable left, NodeVariable right) {
+                return getDnf().callTransitive(left, right);
+        }
+
+        public AssignedValue<Integer> count(List<NodeVariable> arguments) {
+                return getDnf().count(Collections.unmodifiableList(arguments));
+        }
+
+        public AssignedValue<Integer> count(NodeVariable... arguments) {
+                return getDnf().count(arguments);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/SymbolicParameter.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/SymbolicParameter.java
new file mode 100644
index 00000000..e0d3ba1f
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/SymbolicParameter.java
@@ -0,0 +1,52 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.term.Parameter;
+import tools.refinery.store.query.term.ParameterDirection;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Objects;
+
+public final class SymbolicParameter extends Parameter {
+        private final Variable variable;
+
+        public SymbolicParameter(Variable variable, ParameterDirection direction) {
+                super(variable.tryGetType().orElse(null), direction);
+                this.variable = variable;
+        }
+
+        public Variable getVariable() {
+                return variable;
+        }
+
+        public boolean isUnifiable() {
+                return variable.isUnifiable();
+        }
+
+        @Override
+        public String toString() {
+                var direction = getDirection();
+                if (direction == ParameterDirection.OUT) {
+                        return variable.toString();
+                }
+                return "%s %s".formatted(getDirection(), variable);
+        }
+
+        @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;
+                SymbolicParameter that = (SymbolicParameter) o;
+                return Objects.equals(variable, that.variable);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), variable);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback0.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback0.java
new file mode 100644
index 00000000..d98dda2e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback0.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback0 {
+        Collection<Literal> toLiterals();
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback1Data0.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback1Data0.java
new file mode 100644
index 00000000..4c01a527
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback1Data0.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback1Data0 {
+        Collection<Literal> toLiterals(NodeVariable v1);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback1Data1.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback1Data1.java
new file mode 100644
index 00000000..2c0cb6eb
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback1Data1.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback1Data1<T> {
+        Collection<Literal> toLiterals(DataVariable<T> d1);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback2Data0.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback2Data0.java
new file mode 100644
index 00000000..d764bdba
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback2Data0.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback2Data0 {
+        Collection<Literal> toLiterals(NodeVariable v1, NodeVariable v2);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback2Data1.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback2Data1.java
new file mode 100644
index 00000000..140af03a
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback2Data1.java
@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback2Data1<T> {
+        Collection<Literal> toLiterals(NodeVariable v1, DataVariable<T> x1);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback2Data2.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback2Data2.java
new file mode 100644
index 00000000..bfc8637c
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback2Data2.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback2Data2<T1, T2> {
+        Collection<Literal> toLiterals(DataVariable<T1> x1, DataVariable<T2> x2);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback3Data0.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback3Data0.java
new file mode 100644
index 00000000..074df65b
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback3Data0.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback3Data0 {
+        Collection<Literal> toLiterals(NodeVariable v1, NodeVariable v2, NodeVariable v3);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback3Data1.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback3Data1.java
new file mode 100644
index 00000000..24ba5187
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback3Data1.java
@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback3Data1<T> {
+        Collection<Literal> toLiterals(NodeVariable v1, NodeVariable v2, DataVariable<T> d1);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback3Data2.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback3Data2.java
new file mode 100644
index 00000000..2a2e837a
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback3Data2.java
@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback3Data2<T1, T2> {
+        Collection<Literal> toLiterals(NodeVariable v1, DataVariable<T1> d1, DataVariable<T2> d2);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback3Data3.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback3Data3.java
new file mode 100644
index 00000000..8f4bdd01
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback3Data3.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback3Data3<T1, T2, T3> {
+        Collection<Literal> toLiterals(DataVariable<T1> d1, DataVariable<T2> d2, DataVariable<T3> d3);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data0.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data0.java
new file mode 100644
index 00000000..ed0f87b2
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data0.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback4Data0 {
+        Collection<Literal> toLiterals(NodeVariable v1, NodeVariable v2, NodeVariable v3, NodeVariable v4);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data1.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data1.java
new file mode 100644
index 00000000..9b27e2e1
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data1.java
@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback4Data1<T> {
+        Collection<Literal> toLiterals(NodeVariable v1, NodeVariable v2, NodeVariable v3, DataVariable<T> d1);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data2.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data2.java
new file mode 100644
index 00000000..cbc4808e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data2.java
@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback4Data2<T1, T2> {
+        Collection<Literal> toLiterals(NodeVariable v1, NodeVariable v2, DataVariable<T1> d1, DataVariable<T2> d2);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data3.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data3.java
new file mode 100644
index 00000000..a6258f36
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data3.java
@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback4Data3<T1, T2, T3> {
+        Collection<Literal> toLiterals(NodeVariable v1, DataVariable<T1> d1, DataVariable<T2> d2, DataVariable<T3> d3);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data4.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data4.java
new file mode 100644
index 00000000..b52a911a
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/ClauseCallback4Data4.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+
+import java.util.Collection;
+
+@FunctionalInterface
+public interface ClauseCallback4Data4<T1, T2, T3, T4> {
+        Collection<Literal> toLiterals(DataVariable<T1> d1, DataVariable<T2> d2, DataVariable<T3> d3, DataVariable<T4> d4);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback0.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback0.java
new file mode 100644
index 00000000..63b3eee6
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback0.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.dnf.FunctionalQueryBuilder;
+import tools.refinery.store.query.term.DataVariable;
+
+@FunctionalInterface
+public interface FunctionalQueryCallback0<T> {
+        void accept(FunctionalQueryBuilder<T> builder, DataVariable<T> output);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback1.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback1.java
new file mode 100644
index 00000000..1295a118
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback1.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.dnf.FunctionalQueryBuilder;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.NodeVariable;
+
+@FunctionalInterface
+public interface FunctionalQueryCallback1<T> {
+        void accept(FunctionalQueryBuilder<T> builder, NodeVariable p1, DataVariable<T> output);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback2.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback2.java
new file mode 100644
index 00000000..d5b7f9ff
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback2.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.dnf.FunctionalQueryBuilder;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.NodeVariable;
+
+@FunctionalInterface
+public interface FunctionalQueryCallback2<T> {
+        void accept(FunctionalQueryBuilder<T> builder, NodeVariable p1, NodeVariable p2, DataVariable<T> output);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback3.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback3.java
new file mode 100644
index 00000000..dc8404a0
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback3.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.dnf.FunctionalQueryBuilder;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.NodeVariable;
+
+@FunctionalInterface
+public interface FunctionalQueryCallback3<T> {
+        void accept(FunctionalQueryBuilder<T> builder, NodeVariable p1, NodeVariable p2, NodeVariable p3,
+                                DataVariable<T> output);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback4.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback4.java
new file mode 100644
index 00000000..b6d3ddb0
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/FunctionalQueryCallback4.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.dnf.FunctionalQueryBuilder;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.NodeVariable;
+
+@FunctionalInterface
+public interface FunctionalQueryCallback4<T> {
+        void accept(FunctionalQueryBuilder<T> builder, NodeVariable p1, NodeVariable p2, NodeVariable p3, NodeVariable p4,
+                                DataVariable<T> output);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback0.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback0.java
new file mode 100644
index 00000000..3cf1de48
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback0.java
@@ -0,0 +1,13 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.dnf.QueryBuilder;
+
+@FunctionalInterface
+public interface QueryCallback0 {
+        void accept(QueryBuilder builder);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback1.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback1.java
new file mode 100644
index 00000000..0a150955
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback1.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.dnf.QueryBuilder;
+import tools.refinery.store.query.term.NodeVariable;
+
+@FunctionalInterface
+public interface QueryCallback1 {
+        void accept(QueryBuilder builder, NodeVariable p1);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback2.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback2.java
new file mode 100644
index 00000000..9493a7b4
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback2.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.dnf.QueryBuilder;
+import tools.refinery.store.query.term.NodeVariable;
+
+@FunctionalInterface
+public interface QueryCallback2 {
+        void accept(QueryBuilder builder, NodeVariable p1, NodeVariable p2);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback3.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback3.java
new file mode 100644
index 00000000..358c7da7
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback3.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.dnf.QueryBuilder;
+import tools.refinery.store.query.term.NodeVariable;
+
+@FunctionalInterface
+public interface QueryCallback3 {
+        void accept(QueryBuilder builder, NodeVariable p1, NodeVariable p2, NodeVariable p3);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback4.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback4.java
new file mode 100644
index 00000000..890dda16
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/callback/QueryCallback4.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.dnf.callback;
+
+import tools.refinery.store.query.dnf.QueryBuilder;
+import tools.refinery.store.query.term.NodeVariable;
+
+@FunctionalInterface
+public interface QueryCallback4 {
+        void accept(QueryBuilder builder, NodeVariable p1, NodeVariable p2, NodeVariable p3, NodeVariable p4);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/equality/DeepDnfEqualityChecker.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/equality/DeepDnfEqualityChecker.java
new file mode 100644
index 00000000..1eeb5723
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/equality/DeepDnfEqualityChecker.java
@@ -0,0 +1,78 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.equality;
+
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.DnfClause;
+import tools.refinery.store.query.dnf.SymbolicParameter;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.util.CycleDetectingMapper;
+
+import java.util.List;
+
+public class DeepDnfEqualityChecker implements DnfEqualityChecker {
+        private final CycleDetectingMapper<Pair, Boolean> mapper = new CycleDetectingMapper<>(Pair::toString,
+                        this::doCheckEqual);
+
+        @Override
+        public boolean dnfEqual(Dnf left, Dnf right) {
+                return mapper.map(new Pair(left, right));
+        }
+
+        public boolean dnfEqualRaw(List<SymbolicParameter> symbolicParameters,
+                                                           List<? extends List<? extends Literal>> clauses, Dnf other) {
+                int arity = symbolicParameters.size();
+                if (arity != other.arity()) {
+                        return false;
+                }
+                for (int i = 0; i < arity; i++) {
+                        if (!symbolicParameters.get(i).getDirection().equals(other.getSymbolicParameters().get(i).getDirection())) {
+                                return false;
+                        }
+                }
+                int numClauses = clauses.size();
+                if (numClauses != other.getClauses().size()) {
+                        return false;
+                }
+                for (int i = 0; i < numClauses; i++) {
+                        var literalEqualityHelper = new LiteralEqualityHelper(this, symbolicParameters,
+                                        other.getSymbolicParameters());
+                        if (!equalsWithSubstitutionRaw(literalEqualityHelper, clauses.get(i), other.getClauses().get(i))) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+
+        private boolean equalsWithSubstitutionRaw(LiteralEqualityHelper helper, List<? extends Literal> literals,
+                                                                                          DnfClause other) {
+                int size = literals.size();
+                if (size != other.literals().size()) {
+                        return false;
+                }
+                for (int i = 0; i < size; i++) {
+                        if (!literals.get(i).equalsWithSubstitution(helper, other.literals().get(i))) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+
+        protected boolean doCheckEqual(Pair pair) {
+                return pair.left.equalsWithSubstitution(this, pair.right);
+        }
+
+        protected List<Pair> getInProgress() {
+                return mapper.getInProgress();
+        }
+
+        protected record Pair(Dnf left, Dnf right) {
+                @Override
+                public String toString() {
+                        return "(%s, %s)".formatted(left.name(), right.name());
+                }
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/equality/DnfEqualityChecker.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/equality/DnfEqualityChecker.java
new file mode 100644
index 00000000..4a8bee3b
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/equality/DnfEqualityChecker.java
@@ -0,0 +1,13 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.equality;
+
+import tools.refinery.store.query.dnf.Dnf;
+
+@FunctionalInterface
+public interface DnfEqualityChecker {
+        boolean dnfEqual(Dnf left, Dnf right);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/equality/LiteralEqualityHelper.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/equality/LiteralEqualityHelper.java
new file mode 100644
index 00000000..9315fb30
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/equality/LiteralEqualityHelper.java
@@ -0,0 +1,54 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.equality;
+
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.SymbolicParameter;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class LiteralEqualityHelper {
+        private final DnfEqualityChecker dnfEqualityChecker;
+        private final Map<Variable, Variable> leftToRight;
+        private final Map<Variable, Variable> rightToLeft;
+
+        public LiteralEqualityHelper(DnfEqualityChecker dnfEqualityChecker, List<SymbolicParameter> leftParameters,
+                                                                 List<SymbolicParameter> rightParameters) {
+                this.dnfEqualityChecker = dnfEqualityChecker;
+                var arity = leftParameters.size();
+                if (arity != rightParameters.size()) {
+                        throw new IllegalArgumentException("Parameter lists have unequal length");
+                }
+                leftToRight = new HashMap<>(arity);
+                rightToLeft = new HashMap<>(arity);
+                for (int i = 0; i < arity; i++) {
+                        if (!variableEqual(leftParameters.get(i).getVariable(), rightParameters.get(i).getVariable())) {
+                                throw new IllegalArgumentException("Parameter lists cannot be unified: duplicate parameter " + i);
+                        }
+                }
+        }
+
+        public boolean dnfEqual(Dnf left, Dnf right) {
+                return dnfEqualityChecker.dnfEqual(left, right);
+        }
+
+        public boolean variableEqual(Variable left, Variable right) {
+                if (checkMapping(leftToRight, left, right) && checkMapping(rightToLeft, right, left)) {
+                        leftToRight.put(left, right);
+                        rightToLeft.put(right, left);
+                        return true;
+                }
+                return false;
+        }
+
+        private static boolean checkMapping(Map<Variable, Variable> map, Variable key, Variable expectedValue) {
+                var currentValue = map.get(key);
+                return currentValue == null || currentValue.equals(expectedValue);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCallLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCallLiteral.java
new file mode 100644
index 00000000..8ef8e8b4
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCallLiteral.java
@@ -0,0 +1,143 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.ParameterDirection;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.*;
+
+public abstract class AbstractCallLiteral implements Literal {
+        private final Constraint target;
+        private final List<Variable> arguments;
+        private final Set<Variable> inArguments;
+        private final Set<Variable> outArguments;
+
+        // Use exhaustive switch over enums.
+        @SuppressWarnings("squid:S1301")
+        protected AbstractCallLiteral(Constraint target, List<Variable> arguments) {
+                int arity = target.arity();
+                if (arguments.size() != arity) {
+                        throw new IllegalArgumentException("%s needs %d arguments, but got %s".formatted(target.name(),
+                                        target.arity(), arguments.size()));
+                }
+                this.target = target;
+                this.arguments = arguments;
+                var mutableInArguments = new LinkedHashSet<Variable>();
+                var mutableOutArguments = new LinkedHashSet<Variable>();
+                var parameters = target.getParameters();
+                for (int i = 0; i < arity; i++) {
+                        var argument = arguments.get(i);
+                        var parameter = parameters.get(i);
+                        if (!parameter.isAssignable(argument)) {
+                                throw new IllegalArgumentException("Argument %d of %s is not assignable to parameter %s"
+                                                .formatted(i, target, parameter));
+                        }
+                        switch (parameter.getDirection()) {
+                        case IN -> {
+                                if (mutableOutArguments.remove(argument)) {
+                                        checkInOutUnifiable(argument);
+                                }
+                                mutableInArguments.add(argument);
+                        }
+                        case OUT -> {
+                                if (mutableInArguments.contains(argument)) {
+                                        checkInOutUnifiable(argument);
+                                } else if (!mutableOutArguments.add(argument)) {
+                                        checkDuplicateOutUnifiable(argument);
+                                }
+                        }
+                        }
+                }
+                inArguments = Collections.unmodifiableSet(mutableInArguments);
+                outArguments = Collections.unmodifiableSet(mutableOutArguments);
+        }
+
+        private static void checkInOutUnifiable(Variable argument) {
+                if (!argument.isUnifiable()) {
+                        throw new IllegalArgumentException("Argument %s cannot appear with both %s and %s direction"
+                                        .formatted(argument, ParameterDirection.IN, ParameterDirection.OUT));
+                }
+        }
+
+        private static void checkDuplicateOutUnifiable(Variable argument) {
+                if (!argument.isUnifiable()) {
+                        throw new IllegalArgumentException("Argument %s cannot be bound multiple times".formatted(argument));
+                }
+        }
+
+        public Constraint getTarget() {
+                return target;
+        }
+
+        public List<Variable> getArguments() {
+                return arguments;
+        }
+
+        protected Set<Variable> getArgumentsOfDirection(ParameterDirection direction) {
+                return switch (direction) {
+                        case IN -> inArguments;
+                        case OUT -> outArguments;
+                };
+        }
+
+        @Override
+        public Set<Variable> getInputVariables(Set<? extends Variable> positiveVariablesInClause) {
+                var inputVariables = new LinkedHashSet<>(getArgumentsOfDirection(ParameterDirection.OUT));
+                inputVariables.retainAll(positiveVariablesInClause);
+                inputVariables.addAll(getArgumentsOfDirection(ParameterDirection.IN));
+                return Collections.unmodifiableSet(inputVariables);
+        }
+
+        @Override
+        public Set<Variable> getPrivateVariables(Set<? extends Variable> positiveVariablesInClause) {
+                var privateVariables = new LinkedHashSet<>(getArgumentsOfDirection(ParameterDirection.OUT));
+                privateVariables.removeAll(positiveVariablesInClause);
+                return Collections.unmodifiableSet(privateVariables);
+        }
+
+        @Override
+        public Literal substitute(Substitution substitution) {
+                var substitutedArguments = arguments.stream().map(substitution::getSubstitute).toList();
+                return doSubstitute(substitution, substitutedArguments);
+        }
+
+        protected abstract Literal doSubstitute(Substitution substitution, List<Variable> substitutedArguments);
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other) {
+                if (other == null || getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherCallLiteral = (AbstractCallLiteral) other;
+                var arity = arguments.size();
+                if (arity != otherCallLiteral.arguments.size()) {
+                        return false;
+                }
+                for (int i = 0; i < arity; i++) {
+                        if (!helper.variableEqual(arguments.get(i), otherCallLiteral.arguments.get(i))) {
+                                return false;
+                        }
+                }
+                return target.equals(helper, otherCallLiteral.target);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                AbstractCallLiteral that = (AbstractCallLiteral) o;
+                return target.equals(that.target) && arguments.equals(that.arguments);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(getClass(), target, arguments);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AggregationLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AggregationLiteral.java
new file mode 100644
index 00000000..3a5eb5c7
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AggregationLiteral.java
@@ -0,0 +1,138 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.*;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+public class AggregationLiteral<R, T> extends AbstractCallLiteral {
+        private final DataVariable<R> resultVariable;
+        private final DataVariable<T> inputVariable;
+        private final Aggregator<R, T> aggregator;
+
+        public AggregationLiteral(DataVariable<R> resultVariable, Aggregator<R, T> aggregator,
+                                                          DataVariable<T> inputVariable, Constraint target, List<Variable> arguments) {
+                super(target, arguments);
+                if (!inputVariable.getType().equals(aggregator.getInputType())) {
+                        throw new IllegalArgumentException("Input variable %s must of type %s, got %s instead".formatted(
+                                        inputVariable, aggregator.getInputType().getName(), inputVariable.getType().getName()));
+                }
+                if (!getArgumentsOfDirection(ParameterDirection.OUT).contains(inputVariable)) {
+                        throw new IllegalArgumentException("Input variable %s must be bound with direction %s in the argument list"
+                                        .formatted(inputVariable, ParameterDirection.OUT));
+                }
+                if (!resultVariable.getType().equals(aggregator.getResultType())) {
+                        throw new IllegalArgumentException("Result variable %s must of type %s, got %s instead".formatted(
+                                        resultVariable, aggregator.getResultType().getName(), resultVariable.getType().getName()));
+                }
+                if (arguments.contains(resultVariable)) {
+                        throw new IllegalArgumentException("Result variable %s must not appear in the argument list".formatted(
+                                        resultVariable));
+                }
+                this.resultVariable = resultVariable;
+                this.inputVariable = inputVariable;
+                this.aggregator = aggregator;
+        }
+
+        public DataVariable<R> getResultVariable() {
+                return resultVariable;
+        }
+
+        public DataVariable<T> getInputVariable() {
+                return inputVariable;
+        }
+
+        public Aggregator<R, T> getAggregator() {
+                return aggregator;
+        }
+
+        @Override
+        public Set<Variable> getOutputVariables() {
+                return Set.of(resultVariable);
+        }
+
+        @Override
+        public Set<Variable> getInputVariables(Set<? extends Variable> positiveVariablesInClause) {
+                if (positiveVariablesInClause.contains(inputVariable)) {
+                        throw new IllegalArgumentException("Aggregation variable %s must not be bound".formatted(inputVariable));
+                }
+                return super.getInputVariables(positiveVariablesInClause);
+        }
+
+        @Override
+        public Literal reduce() {
+                var reduction = getTarget().getReduction();
+                return switch (reduction) {
+                        case ALWAYS_FALSE -> {
+                                var emptyValue = aggregator.getEmptyResult();
+                                yield emptyValue == null ? BooleanLiteral.FALSE :
+                                                resultVariable.assign(new ConstantTerm<>(resultVariable.getType(), emptyValue));
+                        }
+                        case ALWAYS_TRUE -> throw new IllegalArgumentException("Trying to aggregate over an infinite set");
+                        case NOT_REDUCIBLE -> this;
+                };
+        }
+
+        @Override
+        protected Literal doSubstitute(Substitution substitution, List<Variable> substitutedArguments) {
+                return new AggregationLiteral<>(substitution.getTypeSafeSubstitute(resultVariable), aggregator,
+                                substitution.getTypeSafeSubstitute(inputVariable), getTarget(), substitutedArguments);
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other) {
+                if (!super.equalsWithSubstitution(helper, other)) {
+                        return false;
+                }
+                var otherAggregationLiteral = (AggregationLiteral<?, ?>) other;
+                return helper.variableEqual(resultVariable, otherAggregationLiteral.resultVariable) &&
+                                aggregator.equals(otherAggregationLiteral.aggregator) &&
+                                helper.variableEqual(inputVariable, otherAggregationLiteral.inputVariable);
+        }
+
+        @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;
+                AggregationLiteral<?, ?> that = (AggregationLiteral<?, ?>) o;
+                return resultVariable.equals(that.resultVariable) && inputVariable.equals(that.inputVariable) &&
+                                aggregator.equals(that.aggregator);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), resultVariable, inputVariable, aggregator);
+        }
+
+        @Override
+        public String toString() {
+                var builder = new StringBuilder();
+                builder.append(resultVariable);
+                builder.append(" is ");
+                builder.append(getTarget().toReferenceString());
+                builder.append("(");
+                var argumentIterator = getArguments().iterator();
+                if (argumentIterator.hasNext()) {
+                        var argument = argumentIterator.next();
+                        if (inputVariable.equals(argument)) {
+                                builder.append("@Aggregate(\"").append(aggregator).append("\") ");
+                        }
+                        builder.append(argument);
+                        while (argumentIterator.hasNext()) {
+                                builder.append(", ").append(argumentIterator.next());
+                        }
+                }
+                builder.append(")");
+                return builder.toString();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssignLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssignLiteral.java
new file mode 100644
index 00000000..dbf999a2
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssignLiteral.java
@@ -0,0 +1,79 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Collections;
+import java.util.Objects;
+import java.util.Set;
+
+public record AssignLiteral<T>(DataVariable<T> variable, Term<T> term) implements Literal {
+        public AssignLiteral {
+                if (!term.getType().equals(variable.getType())) {
+                        throw new IllegalArgumentException("Term %s must be of type %s, got %s instead".formatted(
+                                        term, variable.getType().getName(), term.getType().getName()));
+                }
+                var inputVariables = term.getInputVariables();
+                if (inputVariables.contains(variable)) {
+                        throw new IllegalArgumentException("Result variable %s must not appear in the term %s".formatted(
+                                        variable, term));
+                }
+        }
+
+        @Override
+        public Set<Variable> getOutputVariables() {
+                return Set.of(variable);
+        }
+
+        @Override
+        public Set<Variable> getInputVariables(Set<? extends Variable> positiveVariablesInClause) {
+                return Collections.unmodifiableSet(term.getInputVariables());
+        }
+
+        @Override
+        public Set<Variable> getPrivateVariables(Set<? extends Variable> positiveVariablesInClause) {
+                return Set.of();
+        }
+
+        @Override
+        public Literal substitute(Substitution substitution) {
+                return new AssignLiteral<>(substitution.getTypeSafeSubstitute(variable), term.substitute(substitution));
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other) {
+                if (other == null || getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherLetLiteral = (AssignLiteral<?>) other;
+                return helper.variableEqual(variable, otherLetLiteral.variable) && term.equalsWithSubstitution(helper,
+                                otherLetLiteral.term);
+        }
+
+        @Override
+        public String toString() {
+                return "%s is (%s)".formatted(variable, term);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (obj == this) return true;
+                if (obj == null || obj.getClass() != this.getClass()) return false;
+                var that = (AssignLiteral<?>) obj;
+                return Objects.equals(this.variable, that.variable) &&
+                                Objects.equals(this.term, that.term);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(getClass(), variable, term);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssumeLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssumeLiteral.java
new file mode 100644
index 00000000..1ca04c77
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssumeLiteral.java
@@ -0,0 +1,83 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.ConstantTerm;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Collections;
+import java.util.Objects;
+import java.util.Set;
+
+public record AssumeLiteral(Term<Boolean> term) implements Literal {
+        public AssumeLiteral {
+                if (!term.getType().equals(Boolean.class)) {
+                        throw new IllegalArgumentException("Term %s must be of type %s, got %s instead".formatted(
+                                        term, Boolean.class.getName(), term.getType().getName()));
+                }
+        }
+
+        @Override
+        public Set<Variable> getOutputVariables() {
+                return Set.of();
+        }
+
+        @Override
+        public Set<Variable> getInputVariables(Set<? extends Variable> positiveVariablesInClause) {
+                return Collections.unmodifiableSet(term.getInputVariables());
+        }
+
+        @Override
+        public Set<Variable> getPrivateVariables(Set<? extends Variable> positiveVariablesInClause) {
+                return Set.of();
+        }
+
+
+        @Override
+        public Literal substitute(Substitution substitution) {
+                return new AssumeLiteral(term.substitute(substitution));
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other) {
+                if (other == null || getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherAssumeLiteral = (AssumeLiteral) other;
+                return term.equalsWithSubstitution(helper, otherAssumeLiteral.term);
+        }
+
+        @Override
+        public Literal reduce() {
+                if (term instanceof ConstantTerm<Boolean> constantTerm) {
+                        // Return {@link BooleanLiteral#FALSE} for {@code false} or {@code null} literals.
+                        return Boolean.TRUE.equals(constantTerm.getValue()) ? BooleanLiteral.TRUE :
+                                        BooleanLiteral.FALSE;
+                }
+                return this;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s)".formatted(term);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (obj == this) return true;
+                if (obj == null || obj.getClass() != this.getClass()) return false;
+                var that = (AssumeLiteral) obj;
+                return Objects.equals(this.term, that.term);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(getClass(), term);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/BooleanLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/BooleanLiteral.java
new file mode 100644
index 00000000..f312d202
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/BooleanLiteral.java
@@ -0,0 +1,63 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Set;
+
+public enum BooleanLiteral implements CanNegate<BooleanLiteral> {
+        TRUE(true),
+        FALSE(false);
+
+        private final boolean value;
+
+        BooleanLiteral(boolean value) {
+                this.value = value;
+        }
+
+        @Override
+        public Set<Variable> getOutputVariables() {
+                return Set.of();
+        }
+
+        @Override
+        public Set<Variable> getInputVariables(Set<? extends Variable> positiveVariablesInClause) {
+                return Set.of();
+        }
+
+        @Override
+        public Set<Variable> getPrivateVariables(Set<? extends Variable> positiveVariablesInClause) {
+                return Set.of();
+        }
+
+        @Override
+        public Literal substitute(Substitution substitution) {
+                // No variables to substitute.
+                return this;
+        }
+
+        @Override
+        public BooleanLiteral negate() {
+                return fromBoolean(!value);
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other) {
+                return equals(other);
+        }
+
+        @Override
+        public String toString() {
+                return Boolean.toString(value);
+        }
+
+        public static BooleanLiteral fromBoolean(boolean value) {
+                return value ? TRUE : FALSE;
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java
new file mode 100644
index 00000000..29772aee
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java
@@ -0,0 +1,130 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.ParameterDirection;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.*;
+
+public final class CallLiteral extends AbstractCallLiteral implements CanNegate<CallLiteral> {
+        private final CallPolarity polarity;
+
+        public CallLiteral(CallPolarity polarity, Constraint target, List<Variable> arguments) {
+                super(target, arguments);
+                var parameters = target.getParameters();
+                int arity = target.arity();
+                if (polarity.isTransitive()) {
+                        if (arity != 2) {
+                                throw new IllegalArgumentException("Transitive closures can only take binary relations");
+                        }
+                        if (parameters.get(0).isDataVariable() || parameters.get(1).isDataVariable()) {
+                                throw new IllegalArgumentException("Transitive closures can only be computed over nodes");
+                        }
+                }
+                this.polarity = polarity;
+        }
+
+        public CallPolarity getPolarity() {
+                return polarity;
+        }
+
+        @Override
+        protected Literal doSubstitute(Substitution substitution, List<Variable> substitutedArguments) {
+                return new CallLiteral(polarity, getTarget(), substitutedArguments);
+        }
+
+        @Override
+        public Set<Variable> getOutputVariables() {
+                if (polarity.isPositive()) {
+                        return getArgumentsOfDirection(ParameterDirection.OUT);
+                }
+                return Set.of();
+        }
+
+        @Override
+        public Set<Variable> getInputVariables(Set<? extends Variable> positiveVariablesInClause) {
+                if (polarity.isPositive()) {
+                        return getArgumentsOfDirection(ParameterDirection.IN);
+                }
+                return super.getInputVariables(positiveVariablesInClause);
+        }
+
+        @Override
+        public Set<Variable> getPrivateVariables(Set<? extends Variable> positiveVariablesInClause) {
+                if (polarity.isPositive()) {
+                        return Set.of();
+                }
+                return super.getPrivateVariables(positiveVariablesInClause);
+        }
+
+        @Override
+        public Literal reduce() {
+                var reduction = getTarget().getReduction();
+                var negatedReduction = polarity.isPositive() ? reduction : reduction.negate();
+                return switch (negatedReduction) {
+                        case ALWAYS_TRUE -> BooleanLiteral.TRUE;
+                        case ALWAYS_FALSE -> BooleanLiteral.FALSE;
+                        default -> this;
+                };
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other) {
+                if (!super.equalsWithSubstitution(helper, other)) {
+                        return false;
+                }
+                var otherCallLiteral = (CallLiteral) other;
+                return polarity.equals(otherCallLiteral.polarity);
+        }
+
+        @Override
+        public CallLiteral negate() {
+                return new CallLiteral(polarity.negate(), getTarget(), getArguments());
+        }
+
+        @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;
+                CallLiteral that = (CallLiteral) o;
+                return polarity == that.polarity;
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), polarity);
+        }
+
+        @Override
+        public String toString() {
+                var builder = new StringBuilder();
+                if (!polarity.isPositive()) {
+                        builder.append("!(");
+                }
+                builder.append(getTarget().toReferenceString());
+                if (polarity.isTransitive()) {
+                        builder.append("+");
+                }
+                builder.append("(");
+                var argumentIterator = getArguments().iterator();
+                if (argumentIterator.hasNext()) {
+                        builder.append(argumentIterator.next());
+                        while (argumentIterator.hasNext()) {
+                                builder.append(", ").append(argumentIterator.next());
+                        }
+                }
+                builder.append(")");
+                if (!polarity.isPositive()) {
+                        builder.append(")");
+                }
+                return builder.toString();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallPolarity.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallPolarity.java
new file mode 100644
index 00000000..ca70b0fd
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallPolarity.java
@@ -0,0 +1,37 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+public enum CallPolarity {
+        POSITIVE(true, false),
+        NEGATIVE(false, false),
+        TRANSITIVE(true, true);
+
+        private final boolean positive;
+
+        private final boolean transitive;
+
+        CallPolarity(boolean positive, boolean transitive) {
+                this.positive = positive;
+                this.transitive = transitive;
+        }
+
+        public boolean isPositive() {
+                return positive;
+        }
+
+        public boolean isTransitive() {
+                return transitive;
+        }
+
+        public CallPolarity negate() {
+                return switch (this) {
+                        case POSITIVE -> NEGATIVE;
+                        case NEGATIVE -> POSITIVE;
+                        case TRANSITIVE -> throw new IllegalArgumentException("Transitive polarity cannot be negated");
+                };
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CanNegate.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CanNegate.java
new file mode 100644
index 00000000..35dcb3fb
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CanNegate.java
@@ -0,0 +1,10 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+public interface CanNegate<T extends CanNegate<T>> extends Literal {
+        T negate();
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/ConstantLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/ConstantLiteral.java
new file mode 100644
index 00000000..73545620
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/ConstantLiteral.java
@@ -0,0 +1,65 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Objects;
+import java.util.Set;
+
+public record ConstantLiteral(NodeVariable variable, int nodeId) implements Literal {
+        @Override
+        public Set<Variable> getOutputVariables() {
+                return Set.of(variable);
+        }
+
+        @Override
+        public Set<Variable> getInputVariables(Set<? extends Variable> positiveVariablesInClause) {
+                return Set.of();
+        }
+
+        @Override
+        public Set<Variable> getPrivateVariables(Set<? extends Variable> positiveVariablesInClause) {
+                return Set.of();
+        }
+
+        @Override
+        public ConstantLiteral substitute(Substitution substitution) {
+                return new ConstantLiteral(substitution.getTypeSafeSubstitute(variable), nodeId);
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other) {
+                if (other.getClass() != getClass()) {
+                        return false;
+                }
+                var otherConstantLiteral = (ConstantLiteral) other;
+                return helper.variableEqual(variable, otherConstantLiteral.variable) && nodeId == otherConstantLiteral.nodeId;
+        }
+
+
+        @Override
+        public String toString() {
+                return "%s === @Constant %d".formatted(variable, nodeId);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (obj == this) return true;
+                if (obj == null || obj.getClass() != this.getClass()) return false;
+                var that = (ConstantLiteral) obj;
+                return Objects.equals(this.variable, that.variable) &&
+                                this.nodeId == that.nodeId;
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(getClass(), variable, nodeId);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CountLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CountLiteral.java
new file mode 100644
index 00000000..4d4749c8
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CountLiteral.java
@@ -0,0 +1,101 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.term.int_.IntTerms;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+public class CountLiteral extends AbstractCallLiteral {
+        private final DataVariable<Integer> resultVariable;
+
+        public CountLiteral(DataVariable<Integer> resultVariable, Constraint target, List<Variable> arguments) {
+                super(target, arguments);
+                if (!resultVariable.getType().equals(Integer.class)) {
+                        throw new IllegalArgumentException("Count result variable %s must be of type %s, got %s instead".formatted(
+                                        resultVariable, Integer.class.getName(), resultVariable.getType().getName()));
+                }
+                if (arguments.contains(resultVariable)) {
+                        throw new IllegalArgumentException("Count result variable %s must not appear in the argument list"
+                                        .formatted(resultVariable));
+                }
+                this.resultVariable = resultVariable;
+        }
+
+        public DataVariable<Integer> getResultVariable() {
+                return resultVariable;
+        }
+
+        @Override
+        public Set<Variable> getOutputVariables() {
+                return Set.of(resultVariable);
+        }
+
+        @Override
+        public Literal reduce() {
+                var reduction = getTarget().getReduction();
+                return switch (reduction) {
+                        case ALWAYS_FALSE -> getResultVariable().assign(IntTerms.constant(0));
+                        // The only way a constant {@code true} predicate can be called in a negative position is to have all of
+                        // its arguments bound as input variables. Thus, there will only be a single match.
+                        case ALWAYS_TRUE -> getResultVariable().assign(IntTerms.constant(1));
+                        case NOT_REDUCIBLE -> this;
+                };
+        }
+
+        @Override
+        protected Literal doSubstitute(Substitution substitution, List<Variable> substitutedArguments) {
+                return new CountLiteral(substitution.getTypeSafeSubstitute(resultVariable), getTarget(), substitutedArguments);
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other) {
+                if (!super.equalsWithSubstitution(helper, other)) {
+                        return false;
+                }
+                var otherCountLiteral = (CountLiteral) other;
+                return helper.variableEqual(resultVariable, otherCountLiteral.resultVariable);
+        }
+
+        @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;
+                CountLiteral that = (CountLiteral) o;
+                return resultVariable.equals(that.resultVariable);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), resultVariable);
+        }
+
+        @Override
+        public String toString() {
+                var builder = new StringBuilder();
+                builder.append(resultVariable);
+                builder.append(" is count ");
+                builder.append(getTarget().toReferenceString());
+                builder.append("(");
+                var argumentIterator = getArguments().iterator();
+                if (argumentIterator.hasNext()) {
+                        builder.append(argumentIterator.next());
+                        while (argumentIterator.hasNext()) {
+                                builder.append(", ").append(argumentIterator.next());
+                        }
+                }
+                builder.append(")");
+                return builder.toString();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java
new file mode 100644
index 00000000..28ba7625
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java
@@ -0,0 +1,81 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Objects;
+import java.util.Set;
+
+public record EquivalenceLiteral(boolean positive, NodeVariable left, NodeVariable right)
+                implements CanNegate<EquivalenceLiteral> {
+        @Override
+        public Set<Variable> getOutputVariables() {
+                return Set.of(left);
+        }
+
+        @Override
+        public Set<Variable> getInputVariables(Set<? extends Variable> positiveVariablesInClause) {
+                return Set.of(right);
+        }
+
+        @Override
+        public Set<Variable> getPrivateVariables(Set<? extends Variable> positiveVariablesInClause) {
+                return Set.of();
+        }
+
+        @Override
+        public EquivalenceLiteral negate() {
+                return new EquivalenceLiteral(!positive, left, right);
+        }
+
+        @Override
+        public EquivalenceLiteral substitute(Substitution substitution) {
+                return new EquivalenceLiteral(positive, substitution.getTypeSafeSubstitute(left),
+                                substitution.getTypeSafeSubstitute(right));
+        }
+
+        @Override
+        public Literal reduce() {
+                if (left.equals(right)) {
+                        return positive ? BooleanLiteral.TRUE : BooleanLiteral.FALSE;
+                }
+                return this;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other) {
+                if (other.getClass() != getClass()) {
+                        return false;
+                }
+                var otherEquivalenceLiteral = (EquivalenceLiteral) other;
+                return helper.variableEqual(left, otherEquivalenceLiteral.left) && helper.variableEqual(right,
+                                otherEquivalenceLiteral.right);
+        }
+
+        @Override
+        public String toString() {
+                return "%s %s %s".formatted(left, positive ? "===" : "!==", right);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (obj == this) return true;
+                if (obj == null || obj.getClass() != this.getClass()) return false;
+                var that = (EquivalenceLiteral) obj;
+                return this.positive == that.positive &&
+                                Objects.equals(this.left, that.left) &&
+                                Objects.equals(this.right, that.right);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(getClass(), positive, left, right);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/Literal.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/Literal.java
new file mode 100644
index 00000000..ce6c11fe
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/Literal.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Set;
+
+public interface Literal {
+        Set<Variable> getOutputVariables();
+
+        Set<Variable> getInputVariables(Set<? extends Variable> positiveVariablesInClause);
+
+        Set<Variable> getPrivateVariables(Set<? extends Variable> positiveVariablesInClause);
+
+        Literal substitute(Substitution substitution);
+
+        default Literal reduce() {
+                return this;
+        }
+
+        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+        boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/Literals.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/Literals.java
new file mode 100644
index 00000000..b3a87811
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/Literals.java
@@ -0,0 +1,22 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.term.Term;
+
+public final class Literals {
+        private Literals() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static <T extends CanNegate<T>> T not(CanNegate<T> literal) {
+                return literal.negate();
+        }
+
+        public static AssumeLiteral assume(Term<Boolean> term) {
+                return new AssumeLiteral(term);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/Reduction.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/Reduction.java
new file mode 100644
index 00000000..ee155a9a
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/Reduction.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.literal;
+
+public enum Reduction {
+        /**
+         * Signifies that a literal should be preserved in the clause.
+         */
+        NOT_REDUCIBLE,
+
+        /**
+         * Signifies that the literal may be omitted from the cause (if the model being queried is nonempty).
+         */
+        ALWAYS_TRUE,
+
+        /**
+         * Signifies that the clause with the literal may be omitted entirely.
+         */
+        ALWAYS_FALSE;
+
+        public Reduction negate() {
+                return switch (this) {
+                        case NOT_REDUCIBLE -> NOT_REDUCIBLE;
+                        case ALWAYS_TRUE -> ALWAYS_FALSE;
+                        case ALWAYS_FALSE -> ALWAYS_TRUE;
+                };
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/AbstractResultSet.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/AbstractResultSet.java
new file mode 100644
index 00000000..a710c64d
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/AbstractResultSet.java
@@ -0,0 +1,63 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.resultset;
+
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class AbstractResultSet<T> implements ResultSet<T> {
+        private final ModelQueryAdapter adapter;
+        private final Query<T> query;
+        private final List<ResultSetListener<T>> listeners = new ArrayList<>();
+
+        protected AbstractResultSet(ModelQueryAdapter adapter, Query<T> query) {
+                this.adapter = adapter;
+                this.query = query;
+        }
+
+        @Override
+        public ModelQueryAdapter getAdapter() {
+                return adapter;
+        }
+
+        @Override
+        public Query<T> getQuery() {
+                return query;
+        }
+
+        @Override
+        public void addListener(ResultSetListener<T> listener) {
+                if (listeners.isEmpty()) {
+                        startListeningForChanges();
+                }
+                listeners.add(listener);
+        }
+
+        @Override
+        public void removeListener(ResultSetListener<T> listener) {
+                listeners.remove(listener);
+                if (listeners.isEmpty()) {
+                        stopListeningForChanges();
+                }
+        }
+
+        protected abstract void startListeningForChanges();
+
+        protected abstract void stopListeningForChanges();
+
+        protected void notifyChange(Tuple key, T oldValue, T newValue) {
+                int listenerCount = listeners.size();
+                // Use a for loop instead of a for-each loop to avoid {@code Iterator} allocation overhead.
+                //noinspection ForLoopReplaceableByForEach
+                for (int i = 0; i < listenerCount; i++) {
+                        listeners.get(i).put(key, oldValue, newValue);
+                }
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/AnyResultSet.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/AnyResultSet.java
new file mode 100644
index 00000000..02809477
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/AnyResultSet.java
@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.resultset;
+
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.AnyQuery;
+
+public sealed interface AnyResultSet permits ResultSet {
+        ModelQueryAdapter getAdapter();
+
+        AnyQuery getQuery();
+
+        int size();
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/EmptyResultSet.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/EmptyResultSet.java
new file mode 100644
index 00000000..2795a44b
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/EmptyResultSet.java
@@ -0,0 +1,49 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.resultset;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.Cursors;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.tuple.Tuple;
+
+public record EmptyResultSet<T>(ModelQueryAdapter adapter, Query<T> query) implements ResultSet<T> {
+        @Override
+        public ModelQueryAdapter getAdapter() {
+                return adapter;
+        }
+
+        @Override
+        public Query<T> getQuery() {
+                return query;
+        }
+
+        @Override
+        public T get(Tuple parameters) {
+                return query.defaultValue();
+        }
+
+        @Override
+        public Cursor<Tuple, T> getAll() {
+                return Cursors.empty();
+        }
+
+        @Override
+        public int size() {
+                return 0;
+        }
+
+        @Override
+        public void addListener(ResultSetListener<T> listener) {
+                // No need to store the listener, because the empty result set will never change.
+        }
+
+        @Override
+        public void removeListener(ResultSetListener<T> listener) {
+                // No need to remove the listener, because we never stored it.
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/OrderedResultSet.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/OrderedResultSet.java
new file mode 100644
index 00000000..39006d65
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/OrderedResultSet.java
@@ -0,0 +1,80 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.resultset;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.utils.OrderStatisticTree;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Objects;
+
+public class OrderedResultSet<T> implements AutoCloseable, ResultSet<T> {
+        private final ResultSet<T> resultSet;
+        private final OrderStatisticTree<Tuple> tree = new OrderStatisticTree<>();
+        private final ResultSetListener<T> listener = (key, fromValue, toValue) -> {
+                var defaultValue = getQuery().defaultValue();
+                if (Objects.equals(defaultValue, toValue)) {
+                        tree.remove(key);
+                } else {
+                        tree.add(key);
+                }
+        };
+
+        public OrderedResultSet(ResultSet<T> resultSet) {
+                this.resultSet = resultSet;
+                resultSet.addListener(listener);
+                var cursor = resultSet.getAll();
+                while (cursor.move()) {
+                        tree.add(cursor.getKey());
+                }
+        }
+
+        @Override
+        public ModelQueryAdapter getAdapter() {
+                return resultSet.getAdapter();
+        }
+
+        @Override
+        public int size() {
+                return resultSet.size();
+        }
+
+        @Override
+        public Query<T> getQuery() {
+                return resultSet.getQuery();
+        }
+
+        @Override
+        public T get(Tuple parameters) {
+                return resultSet.get(parameters);
+        }
+
+        public Tuple getKey(int index) {
+                return tree.get(index);
+        }
+
+        @Override
+        public Cursor<Tuple, T> getAll() {
+                return resultSet.getAll();
+        }
+
+        @Override
+        public void addListener(ResultSetListener<T> listener) {
+                resultSet.addListener(listener);
+        }
+
+        @Override
+        public void removeListener(ResultSetListener<T> listener) {
+                resultSet.removeListener(listener);
+        }
+
+        @Override
+        public void close() {
+                resultSet.removeListener(listener);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/ResultSet.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/ResultSet.java
new file mode 100644
index 00000000..33d1ea95
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/ResultSet.java
@@ -0,0 +1,22 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.resultset;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.tuple.Tuple;
+
+public non-sealed interface ResultSet<T> extends AnyResultSet {
+        Query<T> getQuery();
+
+        T get(Tuple parameters);
+
+        Cursor<Tuple, T> getAll();
+
+        void addListener(ResultSetListener<T> listener);
+
+        void removeListener(ResultSetListener<T> listener);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/ResultSetListener.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/ResultSetListener.java
new file mode 100644
index 00000000..fd8a503e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/resultset/ResultSetListener.java
@@ -0,0 +1,13 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.resultset;
+
+import tools.refinery.store.tuple.Tuple;
+
+@FunctionalInterface
+public interface ResultSetListener<T> {
+        void put(Tuple key, T fromValue, T toValue);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/MapBasedSubstitution.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/MapBasedSubstitution.java
new file mode 100644
index 00000000..a8201eef
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/MapBasedSubstitution.java
@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.substitution;
+
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Map;
+
+public record MapBasedSubstitution(Map<Variable, Variable> map, Substitution fallback) implements Substitution {
+        @Override
+        public Variable getSubstitute(Variable variable) {
+                var value = map.get(variable);
+                return value == null ? fallback.getSubstitute(variable) : value;
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/RenewingSubstitution.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/RenewingSubstitution.java
new file mode 100644
index 00000000..9b737ceb
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/RenewingSubstitution.java
@@ -0,0 +1,20 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.substitution;
+
+import tools.refinery.store.query.term.Variable;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class RenewingSubstitution implements Substitution {
+        private final Map<Variable, Variable> alreadyRenewed = new HashMap<>();
+
+        @Override
+        public Variable getSubstitute(Variable variable) {
+                return alreadyRenewed.computeIfAbsent(variable, Variable::renew);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/StatelessSubstitution.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/StatelessSubstitution.java
new file mode 100644
index 00000000..bb3803d3
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/StatelessSubstitution.java
@@ -0,0 +1,23 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.substitution;
+
+import tools.refinery.store.query.term.Variable;
+
+public enum StatelessSubstitution implements Substitution {
+        FAILING {
+                @Override
+                public Variable getSubstitute(Variable variable) {
+                        throw new IllegalArgumentException("No substitute for " + variable);
+                }
+        },
+        IDENTITY {
+                @Override
+                public Variable getSubstitute(Variable variable) {
+                        return variable;
+                }
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/Substitution.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/Substitution.java
new file mode 100644
index 00000000..834fce12
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/Substitution.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.substitution;
+
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.query.term.Variable;
+
+@FunctionalInterface
+public interface Substitution {
+        Variable getSubstitute(Variable variable);
+
+        default NodeVariable getTypeSafeSubstitute(NodeVariable variable) {
+                var substitute = getSubstitute(variable);
+                return substitute.asNodeVariable();
+        }
+
+        default <T> DataVariable<T> getTypeSafeSubstitute(DataVariable<T> variable) {
+                var substitute = getSubstitute(variable);
+                return substitute.asDataVariable(variable.getType());
+        }
+
+        static SubstitutionBuilder builder() {
+                return new SubstitutionBuilder();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/SubstitutionBuilder.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/SubstitutionBuilder.java
new file mode 100644
index 00000000..37fb6908
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/SubstitutionBuilder.java
@@ -0,0 +1,79 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.substitution;
+
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@SuppressWarnings("UnusedReturnValue")
+public class SubstitutionBuilder {
+        private final Map<Variable, Variable> map = new HashMap<>();
+        private Substitution fallback;
+
+        SubstitutionBuilder() {
+                total();
+        }
+
+        public SubstitutionBuilder put(NodeVariable original, NodeVariable substitute) {
+                return putChecked(original, substitute);
+        }
+
+        public <T> SubstitutionBuilder put(DataVariable<T> original, DataVariable<T> substitute) {
+                return putChecked(original, substitute);
+        }
+
+        public SubstitutionBuilder putChecked(Variable original, Variable substitute) {
+                if (!original.tryGetType().equals(substitute.tryGetType())) {
+                        throw new IllegalArgumentException("Cannot substitute variable %s of sort %s with variable %s of sort %s"
+                                        .formatted(original, original.tryGetType().map(Class::getName).orElse("node"), substitute,
+                                                        substitute.tryGetType().map(Class::getName).orElse("node")));
+                }
+                if (map.containsKey(original)) {
+                        throw new IllegalArgumentException("Already has substitution for variable %s".formatted(original));
+                }
+                map.put(original, substitute);
+                return this;
+        }
+
+        public SubstitutionBuilder putManyChecked(List<Variable> originals, List<Variable> substitutes) {
+                int size = originals.size();
+                if (size != substitutes.size()) {
+                        throw new IllegalArgumentException("Cannot substitute %d variables %s with %d variables %s"
+                                        .formatted(size, originals, substitutes.size(), substitutes));
+                }
+                for (int i = 0; i < size; i++) {
+                        putChecked(originals.get(i), substitutes.get(i));
+                }
+                return this;
+        }
+
+        public SubstitutionBuilder fallback(Substitution newFallback) {
+                fallback = newFallback;
+                return this;
+        }
+
+        public SubstitutionBuilder total() {
+                return fallback(StatelessSubstitution.FAILING);
+        }
+
+        public SubstitutionBuilder partial() {
+                return fallback(StatelessSubstitution.IDENTITY);
+        }
+
+        public SubstitutionBuilder renewing() {
+                return fallback(new RenewingSubstitution());
+        }
+
+        public Substitution build() {
+                return map.isEmpty() ? fallback : new MapBasedSubstitution(Collections.unmodifiableMap(map), fallback);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AbstractTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AbstractTerm.java
new file mode 100644
index 00000000..d0ae3c12
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AbstractTerm.java
@@ -0,0 +1,41 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+
+import java.util.Objects;
+
+public abstract class AbstractTerm<T> implements Term<T> {
+        private final Class<T> type;
+
+        protected AbstractTerm(Class<T> type) {
+                this.type = type;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, AnyTerm other) {
+                return getClass().equals(other.getClass()) && type.equals(other.getType());
+        }
+
+        @Override
+        public Class<T> getType() {
+                return type;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                AbstractTerm<?> that = (AbstractTerm<?>) o;
+                return type.equals(that.type);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(getClass(), type);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Aggregator.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Aggregator.java
new file mode 100644
index 00000000..0684a9d9
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Aggregator.java
@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import java.util.stream.Stream;
+
+public interface Aggregator<R, T> {
+        Class<R> getResultType();
+
+        Class<T> getInputType();
+
+        R aggregateStream(Stream<T> stream);
+
+        R getEmptyResult();
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyDataVariable.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyDataVariable.java
new file mode 100644
index 00000000..192c39c5
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyDataVariable.java
@@ -0,0 +1,49 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+
+import java.util.Optional;
+import java.util.Set;
+
+public abstract sealed class AnyDataVariable extends Variable implements AnyTerm permits DataVariable {
+        protected AnyDataVariable(String name) {
+                super(name);
+        }
+
+        @Override
+        public Optional<Class<?>> tryGetType() {
+                return Optional.of(getType());
+        }
+
+        @Override
+        public NodeVariable asNodeVariable() {
+                throw new IllegalStateException("%s is a data variable".formatted(this));
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, AnyTerm other) {
+                return other instanceof AnyDataVariable dataVariable && helper.variableEqual(this, dataVariable);
+        }
+
+        @Override
+        public Set<AnyDataVariable> getInputVariables() {
+                return Set.of(this);
+        }
+
+        @Override
+        public boolean isUnifiable() {
+                return false;
+        }
+
+        @Override
+        public abstract AnyDataVariable renew(@Nullable String name);
+
+        @Override
+        public abstract AnyDataVariable renew();
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyTerm.java
new file mode 100644
index 00000000..c12c0166
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyTerm.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+
+import java.util.Set;
+
+public sealed interface AnyTerm permits AnyDataVariable, Term {
+        Class<?> getType();
+
+        AnyTerm substitute(Substitution substitution);
+
+        boolean equalsWithSubstitution(LiteralEqualityHelper helper, AnyTerm other);
+
+        Set<AnyDataVariable> getInputVariables();
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AssignedValue.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AssignedValue.java
new file mode 100644
index 00000000..0cf30aa6
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AssignedValue.java
@@ -0,0 +1,13 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import tools.refinery.store.query.literal.Literal;
+
+@FunctionalInterface
+public interface AssignedValue<T> {
+        Literal toLiteral(DataVariable<T> targetVariable);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/BinaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/BinaryTerm.java
new file mode 100644
index 00000000..8ad17839
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/BinaryTerm.java
@@ -0,0 +1,113 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.valuation.Valuation;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+
+public abstract class BinaryTerm<R, T1, T2> extends AbstractTerm<R> {
+        private final Class<T1> leftType;
+        private final Class<T2> rightType;
+        private final Term<T1> left;
+        private final Term<T2> right;
+
+        protected BinaryTerm(Class<R> type, Class<T1> leftType, Class<T2> rightType, Term<T1> left, Term<T2> right) {
+                super(type);
+                if (!left.getType().equals(leftType)) {
+                        throw new IllegalArgumentException("Expected left %s to be of type %s, got %s instead".formatted(
+                                        left, leftType.getName(), left.getType().getName()));
+                }
+                if (!right.getType().equals(rightType)) {
+                        throw new IllegalArgumentException("Expected right %s to be of type %s, got %s instead".formatted(
+                                        right, rightType.getName(), right.getType().getName()));
+                }
+                this.leftType = leftType;
+                this.rightType = rightType;
+                this.left = left;
+                this.right = right;
+        }
+
+        public Class<T1> getLeftType() {
+                return leftType;
+        }
+
+        public Class<T2> getRightType() {
+                return rightType;
+        }
+
+        public Term<T1> getLeft() {
+                return left;
+        }
+
+        public Term<T2> getRight() {
+                return right;
+        }
+
+        @Override
+        public R evaluate(Valuation valuation) {
+                var leftValue = left.evaluate(valuation);
+                if (leftValue == null) {
+                        return null;
+                }
+                var rightValue = right.evaluate(valuation);
+                if (rightValue == null) {
+                        return null;
+                }
+                return doEvaluate(leftValue, rightValue);
+        }
+
+        protected abstract R doEvaluate(T1 leftValue, T2 rightValue);
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, AnyTerm other) {
+                if (!super.equalsWithSubstitution(helper, other)) {
+                        return false;
+                }
+                var otherBinaryTerm = (BinaryTerm<?, ?, ?>) other;
+                return leftType.equals(otherBinaryTerm.leftType) &&
+                                rightType.equals(otherBinaryTerm.rightType) &&
+                                left.equalsWithSubstitution(helper, otherBinaryTerm.left) &&
+                                right.equalsWithSubstitution(helper, otherBinaryTerm.right);
+        }
+
+        @Override
+        public Term<R> substitute(Substitution substitution) {
+                return doSubstitute(substitution, left.substitute(substitution), right.substitute(substitution));
+        }
+
+        public abstract Term<R> doSubstitute(Substitution substitution, Term<T1> substitutedLeft,
+                                                                                 Term<T2> substitutedRight);
+
+        @Override
+        public Set<AnyDataVariable> getInputVariables() {
+                var inputVariables = new HashSet<>(left.getInputVariables());
+                inputVariables.addAll(right.getInputVariables());
+                return Collections.unmodifiableSet(inputVariables);
+        }
+
+        @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;
+                BinaryTerm<?, ?, ?> that = (BinaryTerm<?, ?, ?>) o;
+                return Objects.equals(leftType, that.leftType) &&
+                                Objects.equals(rightType, that.rightType) &&
+                                Objects.equals(left, that.left) &&
+                                Objects.equals(right, that.right);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), leftType, rightType, left, right);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ConstantTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ConstantTerm.java
new file mode 100644
index 00000000..2f6c56d1
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ConstantTerm.java
@@ -0,0 +1,71 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.valuation.Valuation;
+
+import java.util.Objects;
+import java.util.Set;
+
+public final class ConstantTerm<T> extends AbstractTerm<T> {
+        private final T value;
+
+        public ConstantTerm(Class<T> type, T value) {
+                super(type);
+                if (value != null && !type.isInstance(value)) {
+                        throw new IllegalArgumentException("Value %s is not an instance of %s".formatted(value, type.getName()));
+                }
+                this.value = value;
+        }
+
+        public T getValue() {
+                return value;
+        }
+
+        @Override
+        public T evaluate(Valuation valuation) {
+                return getValue();
+        }
+
+        @Override
+        public Term<T> substitute(Substitution substitution) {
+                return this;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, AnyTerm other) {
+                if (!super.equalsWithSubstitution(helper, other)) {
+                        return false;
+                }
+                var otherConstantTerm = (ConstantTerm<?>) other;
+                return Objects.equals(value, otherConstantTerm.value);
+        }
+
+        @Override
+        public Set<AnyDataVariable> getInputVariables() {
+                return Set.of();
+        }
+
+        @Override
+        public String toString() {
+                return value.toString();
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                ConstantTerm<?> that = (ConstantTerm<?>) o;
+                return Objects.equals(value, that.value);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(value);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataVariable.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataVariable.java
new file mode 100644
index 00000000..00950360
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataVariable.java
@@ -0,0 +1,82 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.valuation.Valuation;
+
+import java.util.Objects;
+
+public final class DataVariable<T> extends AnyDataVariable implements Term<T> {
+        private final Class<T> type;
+
+        DataVariable(String name, Class<T> type) {
+                super(name);
+                this.type = type;
+        }
+
+        @Override
+        public Class<T> getType() {
+                return type;
+        }
+
+        @Override
+        public DataVariable<T> renew(@Nullable String name) {
+                return new DataVariable<>(name, type);
+        }
+
+        @Override
+        public DataVariable<T> renew() {
+                return renew(getExplicitName());
+        }
+
+        @Override
+        public <U> DataVariable<U> asDataVariable(Class<U> newType) {
+                if (!getType().equals(newType)) {
+                        throw new IllegalStateException("%s is not of type %s but of type %s".formatted(this, newType.getName(),
+                                        getType().getName()));
+                }
+                @SuppressWarnings("unchecked")
+                var result = (DataVariable<U>) this;
+                return result;
+        }
+
+        @Override
+        public T evaluate(Valuation valuation) {
+                return valuation.getValue(this);
+        }
+
+        @Override
+        public Term<T> substitute(Substitution substitution) {
+                return substitution.getTypeSafeSubstitute(this);
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, AnyTerm other) {
+                return other instanceof DataVariable<?> dataVariable && helper.variableEqual(this, dataVariable);
+        }
+
+        public Literal assign(AssignedValue<T> value) {
+                return value.toLiteral(this);
+        }
+
+        @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;
+                DataVariable<?> that = (DataVariable<?>) o;
+                return type.equals(that.type);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), type);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ExtremeValueAggregator.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ExtremeValueAggregator.java
new file mode 100644
index 00000000..657cb631
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ExtremeValueAggregator.java
@@ -0,0 +1,108 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import java.util.Comparator;
+import java.util.Objects;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+public class ExtremeValueAggregator<T> implements StatefulAggregator<T, T> {
+        private final Class<T> type;
+        private final T emptyResult;
+        private final Comparator<T> comparator;
+
+        public ExtremeValueAggregator(Class<T> type, T emptyResult) {
+                this(type, emptyResult, null);
+        }
+
+        public ExtremeValueAggregator(Class<T> type, T emptyResult, Comparator<T> comparator) {
+                this.type = type;
+                this.emptyResult = emptyResult;
+                this.comparator = comparator;
+        }
+
+        @Override
+        public Class<T> getResultType() {
+                return getInputType();
+        }
+
+        @Override
+        public Class<T> getInputType() {
+                return type;
+        }
+
+        @Override
+        public StatefulAggregate<T, T> createEmptyAggregate() {
+                return new Aggregate();
+        }
+
+        @Override
+        public T getEmptyResult() {
+                return emptyResult;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                ExtremeValueAggregator<?> that = (ExtremeValueAggregator<?>) o;
+                return type.equals(that.type) && Objects.equals(emptyResult, that.emptyResult) && Objects.equals(comparator,
+                                that.comparator);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(type, emptyResult, comparator);
+        }
+
+        private class Aggregate implements StatefulAggregate<T, T> {
+                private final SortedMap<T, Integer> values;
+
+                private Aggregate() {
+                        values = new TreeMap<>(comparator);
+                }
+
+                private Aggregate(Aggregate other) {
+                        values = new TreeMap<>(other.values);
+                }
+
+                @Override
+                public void add(T value) {
+                        values.compute(value, (ignoredValue, currentCount) -> currentCount == null ? 1 : currentCount + 1);
+                }
+
+                @Override
+                public void remove(T value) {
+                        values.compute(value, (theValue, currentCount) -> {
+                                if (currentCount == null || currentCount <= 0) {
+                                        throw new IllegalStateException("Invalid count %d for value %s".formatted(currentCount, theValue));
+                                }
+                                return currentCount.equals(1) ? null : currentCount - 1;
+                        });
+                }
+
+                @Override
+                public T getResult() {
+                        return isEmpty() ? emptyResult : values.firstKey();
+                }
+
+                @Override
+                public boolean isEmpty() {
+                        return values.isEmpty();
+                }
+
+                @Override
+                public StatefulAggregate<T, T> deepCopy() {
+                        return new Aggregate(this);
+                }
+
+                @Override
+                public boolean contains(T value) {
+                        return StatefulAggregate.super.contains(value);
+                }
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeVariable.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeVariable.java
new file mode 100644
index 00000000..a2f3261f
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeVariable.java
@@ -0,0 +1,60 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.query.literal.ConstantLiteral;
+import tools.refinery.store.query.literal.EquivalenceLiteral;
+
+import java.util.Optional;
+
+public final class NodeVariable extends Variable {
+        NodeVariable(@Nullable String name) {
+                super(name);
+        }
+
+        @Override
+        public Optional<Class<?>> tryGetType() {
+                return Optional.empty();
+        }
+
+        @Override
+        public boolean isUnifiable() {
+                return true;
+        }
+
+        @Override
+        public NodeVariable renew(@Nullable String name) {
+                return Variable.of(name);
+        }
+
+        @Override
+        public NodeVariable renew() {
+                return renew(getExplicitName());
+        }
+
+        @Override
+        public NodeVariable asNodeVariable() {
+                return this;
+        }
+
+        @Override
+        public <T> DataVariable<T> asDataVariable(Class<T> type) {
+                throw new IllegalStateException("%s is a node variable".formatted(this));
+        }
+
+        public ConstantLiteral isConstant(int value) {
+                return new ConstantLiteral(this, value);
+        }
+
+        public EquivalenceLiteral isEquivalent(NodeVariable other) {
+                return new EquivalenceLiteral(true, this, other);
+        }
+
+        public EquivalenceLiteral notEquivalent(NodeVariable other) {
+                return new EquivalenceLiteral(false, this, other);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Parameter.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Parameter.java
new file mode 100644
index 00000000..e5a0cdf1
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Parameter.java
@@ -0,0 +1,60 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import java.util.Objects;
+import java.util.Optional;
+
+public class Parameter {
+        public static final Parameter NODE_OUT = new Parameter(null, ParameterDirection.OUT);
+
+        private final Class<?> dataType;
+        private final ParameterDirection direction;
+
+        public Parameter(Class<?> dataType, ParameterDirection direction) {
+                this.dataType = dataType;
+                this.direction = direction;
+        }
+
+        public boolean isNodeVariable() {
+                return dataType == null;
+        }
+
+        public boolean isDataVariable() {
+                return !isNodeVariable();
+        }
+
+        public Optional<Class<?>> tryGetType() {
+                return Optional.ofNullable(dataType);
+        }
+
+        public ParameterDirection getDirection() {
+                return direction;
+        }
+
+        public boolean isAssignable(Variable variable) {
+                if (variable instanceof AnyDataVariable dataVariable) {
+                        return dataVariable.getType().equals(dataType);
+                } else if (variable instanceof NodeVariable) {
+                        return !isDataVariable();
+                } else {
+                        throw new IllegalArgumentException("Unknown variable " + variable);
+                }
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                Parameter parameter = (Parameter) o;
+                return Objects.equals(dataType, parameter.dataType) && direction == parameter.direction;
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(dataType, direction);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ParameterDirection.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ParameterDirection.java
new file mode 100644
index 00000000..cd0739be
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ParameterDirection.java
@@ -0,0 +1,22 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+public enum ParameterDirection {
+        OUT("@Out"),
+        IN("@In");
+
+        private final String name;
+
+        ParameterDirection(String name) {
+                this.name = name;
+        }
+
+        @Override
+        public String toString() {
+                return name;
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/StatefulAggregate.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/StatefulAggregate.java
new file mode 100644
index 00000000..ab310556
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/StatefulAggregate.java
@@ -0,0 +1,22 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+public interface StatefulAggregate<R, T> {
+        void add(T value);
+
+        void remove(T value);
+
+        R getResult();
+
+        boolean isEmpty();
+
+        StatefulAggregate<R, T> deepCopy();
+
+        default boolean contains(T value) {
+                throw new UnsupportedOperationException();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/StatefulAggregator.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/StatefulAggregator.java
new file mode 100644
index 00000000..df746a90
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/StatefulAggregator.java
@@ -0,0 +1,28 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import java.util.stream.Stream;
+
+public interface StatefulAggregator<R, T> extends Aggregator<R, T> {
+        StatefulAggregate<R, T> createEmptyAggregate();
+
+        @Override
+        default R aggregateStream(Stream<T> stream) {
+                var accumulator = createEmptyAggregate();
+                var iterator = stream.iterator();
+                while (iterator.hasNext()) {
+                        var value = iterator.next();
+                        accumulator.add(value);
+                }
+                return accumulator.getResult();
+        }
+
+        @Override
+        default R getEmptyResult() {
+                return createEmptyAggregate().getResult();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/StatelessAggregator.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/StatelessAggregator.java
new file mode 100644
index 00000000..a094919e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/StatelessAggregator.java
@@ -0,0 +1,25 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import java.util.stream.Stream;
+
+public interface StatelessAggregator<R, T> extends Aggregator<R, T> {
+        R add(R current, T value);
+
+        R remove(R current, T value);
+
+        @Override
+        default R aggregateStream(Stream<T> stream) {
+                var accumulator = getEmptyResult();
+                var iterator = stream.iterator();
+                while (iterator.hasNext()) {
+                        var value = iterator.next();
+                        accumulator = add(accumulator, value);
+                }
+                return accumulator;
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Term.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Term.java
new file mode 100644
index 00000000..e6818b88
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Term.java
@@ -0,0 +1,26 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import tools.refinery.store.query.literal.AssignLiteral;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.valuation.Valuation;
+
+public non-sealed interface Term<T> extends AnyTerm, AssignedValue<T> {
+        @Override
+        Class<T> getType();
+
+        T evaluate(Valuation valuation);
+
+        @Override
+        Term<T> substitute(Substitution substitution);
+
+        @Override
+        default Literal toLiteral(DataVariable<T> targetVariable) {
+                return new AssignLiteral<>(targetVariable, this);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/UnaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/UnaryTerm.java
new file mode 100644
index 00000000..a46ebe31
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/UnaryTerm.java
@@ -0,0 +1,79 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.valuation.Valuation;
+
+import java.util.Objects;
+import java.util.Set;
+
+public abstract class UnaryTerm<R, T> extends AbstractTerm<R> {
+        private final Class<T> bodyType;
+        private final Term<T> body;
+
+        protected UnaryTerm(Class<R> type, Class<T> bodyType, Term<T> body) {
+                super(type);
+                if (!body.getType().equals(bodyType)) {
+                        throw new IllegalArgumentException("Expected body %s to be of type %s, got %s instead".formatted(body,
+                                        bodyType.getName(), body.getType().getName()));
+                }
+                this.bodyType = bodyType;
+                this.body = body;
+        }
+
+        public Class<T> getBodyType() {
+                return bodyType;
+        }
+
+        public Term<T> getBody() {
+                return body;
+        }
+
+        @Override
+        public R evaluate(Valuation valuation) {
+                var bodyValue = body.evaluate(valuation);
+                return bodyValue == null ? null : doEvaluate(bodyValue);
+        }
+
+        protected abstract R doEvaluate(T bodyValue);
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, AnyTerm other) {
+                if (!super.equalsWithSubstitution(helper, other)) {
+                        return false;
+                }
+                var otherUnaryTerm = (UnaryTerm<?, ?>) other;
+                return bodyType.equals(otherUnaryTerm.bodyType) && body.equalsWithSubstitution(helper, otherUnaryTerm.body);
+        }
+
+        @Override
+        public Term<R> substitute(Substitution substitution) {
+                return doSubstitute(substitution, body.substitute(substitution));
+        }
+
+        protected abstract Term<R> doSubstitute(Substitution substitution, Term<T> substitutedBody);
+
+        @Override
+        public Set<AnyDataVariable> getInputVariables() {
+                return body.getInputVariables();
+        }
+
+        @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;
+                UnaryTerm<?, ?> unaryTerm = (UnaryTerm<?, ?>) o;
+                return Objects.equals(bodyType, unaryTerm.bodyType) && Objects.equals(body, unaryTerm.body);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), bodyType, body);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Variable.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Variable.java
new file mode 100644
index 00000000..a0268c8e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Variable.java
@@ -0,0 +1,84 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term;
+
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.query.dnf.DnfUtils;
+
+import java.util.Objects;
+import java.util.Optional;
+
+public abstract sealed class Variable permits AnyDataVariable, NodeVariable {
+        private final String explicitName;
+        private final String uniqueName;
+
+        protected Variable(String name) {
+                this.explicitName = name;
+                uniqueName = DnfUtils.generateUniqueName(name);
+        }
+
+        public abstract Optional<Class<?>> tryGetType();
+
+        public String getName() {
+                return explicitName == null ? uniqueName : explicitName;
+        }
+
+        protected String getExplicitName() {
+                return explicitName;
+        }
+
+        public boolean isExplicitlyNamed() {
+                return explicitName != null;
+        }
+
+        public String getUniqueName() {
+                return uniqueName;
+        }
+
+        public abstract boolean isUnifiable();
+
+        public abstract Variable renew(@Nullable String name);
+
+        public abstract Variable renew();
+
+        public abstract NodeVariable asNodeVariable();
+
+        public abstract <T> DataVariable<T> asDataVariable(Class<T> type);
+
+        @Override
+        public String toString() {
+                return getName();
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                Variable variable = (Variable) o;
+                return Objects.equals(uniqueName, variable.uniqueName);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(uniqueName);
+        }
+
+        public static NodeVariable of(@Nullable String name) {
+                return new NodeVariable(name);
+        }
+
+        public static NodeVariable of() {
+                return of((String) null);
+        }
+
+        public static <T> DataVariable<T> of(@Nullable String name, Class<T> type) {
+                return new DataVariable<>(name, type);
+        }
+
+        public static <T> DataVariable<T> of(Class<T> type) {
+                return of(null, type);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolAndTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolAndTerm.java
new file mode 100644
index 00000000..f9e1c06f
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolAndTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.bool;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class BoolAndTerm extends BoolBinaryTerm {
+        public BoolAndTerm(Term<Boolean> left, Term<Boolean> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Boolean> doSubstitute(Substitution substitution, Term<Boolean> substitutedLeft,
+                                                                          Term<Boolean> substitutedRight) {
+                return new BoolAndTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Boolean doEvaluate(Boolean leftValue, Boolean rightValue) {
+                return leftValue && rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s && %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolBinaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolBinaryTerm.java
new file mode 100644
index 00000000..a85aa63a
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolBinaryTerm.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.bool;
+
+import tools.refinery.store.query.term.BinaryTerm;
+import tools.refinery.store.query.term.Term;
+
+public abstract class BoolBinaryTerm extends BinaryTerm<Boolean, Boolean, Boolean> {
+        protected BoolBinaryTerm(Term<Boolean> left, Term<Boolean> right) {
+                super(Boolean.class, Boolean.class, Boolean.class, left, right);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolNotTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolNotTerm.java
new file mode 100644
index 00000000..8d3382b3
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolNotTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.bool;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.query.term.UnaryTerm;
+
+public class BoolNotTerm extends UnaryTerm<Boolean, Boolean> {
+        protected BoolNotTerm(Term<Boolean> body) {
+                super(Boolean.class, Boolean.class, body);
+        }
+
+        @Override
+        protected Term<Boolean> doSubstitute(Substitution substitution, Term<Boolean> substitutedBody) {
+                return new BoolNotTerm(substitutedBody);
+        }
+
+        @Override
+        protected Boolean doEvaluate(Boolean bodyValue) {
+                return !bodyValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(!%s)".formatted(getBody());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolOrTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolOrTerm.java
new file mode 100644
index 00000000..b5195d52
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolOrTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.bool;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class BoolOrTerm extends BoolBinaryTerm {
+        public BoolOrTerm(Term<Boolean> left, Term<Boolean> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Boolean> doSubstitute(Substitution substitution, Term<Boolean> substitutedLeft,
+                                                                          Term<Boolean> substitutedRight) {
+                return new BoolOrTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Boolean doEvaluate(Boolean leftValue, Boolean rightValue) {
+                return leftValue || rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s || %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolTerms.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolTerms.java
new file mode 100644
index 00000000..fa54f686
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolTerms.java
@@ -0,0 +1,35 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.bool;
+
+import tools.refinery.store.query.term.ConstantTerm;
+import tools.refinery.store.query.term.Term;
+
+public final class BoolTerms {
+        private BoolTerms() {
+                throw new IllegalArgumentException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static Term<Boolean> constant(Boolean value) {
+                return new ConstantTerm<>(Boolean.class, value);
+        }
+
+        public static Term<Boolean> not(Term<Boolean> body) {
+                return new BoolNotTerm(body);
+        }
+
+        public static Term<Boolean> and(Term<Boolean> left, Term<Boolean> right) {
+                return new BoolAndTerm(left, right);
+        }
+
+        public static Term<Boolean> or(Term<Boolean> left, Term<Boolean> right) {
+                return new BoolOrTerm(left, right);
+        }
+
+        public static Term<Boolean> xor(Term<Boolean> left, Term<Boolean> right) {
+                return new BoolXorTerm(left, right);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolXorTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolXorTerm.java
new file mode 100644
index 00000000..7478b8a5
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolXorTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.bool;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class BoolXorTerm extends BoolBinaryTerm {
+        public BoolXorTerm(Term<Boolean> left, Term<Boolean> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Boolean> doSubstitute(Substitution substitution, Term<Boolean> substitutedLeft,
+                                                                          Term<Boolean> substitutedRight) {
+                return new BoolXorTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Boolean doEvaluate(Boolean leftValue, Boolean rightValue) {
+                return leftValue ^ rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s ^^ %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/ComparisonTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/ComparisonTerm.java
new file mode 100644
index 00000000..5ca5a0a1
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/ComparisonTerm.java
@@ -0,0 +1,19 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.comparable;
+
+import tools.refinery.store.query.term.BinaryTerm;
+import tools.refinery.store.query.term.Term;
+
+public abstract class ComparisonTerm<T> extends BinaryTerm<Boolean, T, T> {
+        protected ComparisonTerm(Class<T> argumentType, Term<T> left, Term<T> right) {
+                super(Boolean.class, argumentType, argumentType, left, right);
+        }
+
+        public Class<T> getArgumentType() {
+                return getLeftType();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/EqTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/EqTerm.java
new file mode 100644
index 00000000..b8cf36f8
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/EqTerm.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.comparable;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class EqTerm<T> extends ComparisonTerm<T> {
+        public EqTerm(Class<T> argumentType, Term<T> left, Term<T> right) {
+                super(argumentType, left, right);
+        }
+
+        @Override
+        protected Boolean doEvaluate(T leftValue, T rightValue) {
+                return leftValue.equals(rightValue);
+        }
+
+        @Override
+        public Term<Boolean> doSubstitute(Substitution substitution, Term<T> substitutedLeft, Term<T> substitutedRight) {
+                return new EqTerm<>(getArgumentType(), substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        public String toString() {
+                return "(%s == %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/GreaterEqTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/GreaterEqTerm.java
new file mode 100644
index 00000000..b109eb1a
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/GreaterEqTerm.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.comparable;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class GreaterEqTerm<T extends Comparable<T>> extends ComparisonTerm<T> {
+        public GreaterEqTerm(Class<T> argumentType, Term<T> left, Term<T> right) {
+                super(argumentType, left, right);
+        }
+
+        @Override
+        protected Boolean doEvaluate(T leftValue, T rightValue) {
+                return leftValue.compareTo(rightValue) >= 0;
+        }
+
+        @Override
+        public Term<Boolean> doSubstitute(Substitution substitution, Term<T> substitutedLeft, Term<T> substitutedRight) {
+                return new GreaterEqTerm<>(getArgumentType(), substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        public String toString() {
+                return "(%s >= %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/GreaterTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/GreaterTerm.java
new file mode 100644
index 00000000..1b67f8b5
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/GreaterTerm.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.comparable;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class GreaterTerm<T extends Comparable<T>> extends ComparisonTerm<T> {
+        public GreaterTerm(Class<T> argumentType, Term<T> left, Term<T> right) {
+                super(argumentType, left, right);
+        }
+
+        @Override
+        protected Boolean doEvaluate(T leftValue, T rightValue) {
+                return leftValue.compareTo(rightValue) > 0;
+        }
+
+        @Override
+        public Term<Boolean> doSubstitute(Substitution substitution, Term<T> substitutedLeft, Term<T> substitutedRight) {
+                return new GreaterTerm<>(getArgumentType(), substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        public String toString() {
+                return "(%s > %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/LessEqTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/LessEqTerm.java
new file mode 100644
index 00000000..1b34535f
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/LessEqTerm.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.comparable;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class LessEqTerm<T extends Comparable<T>> extends ComparisonTerm<T> {
+        public LessEqTerm(Class<T> argumentType, Term<T> left, Term<T> right) {
+                super(argumentType, left, right);
+        }
+
+        @Override
+        protected Boolean doEvaluate(T leftValue, T rightValue) {
+                return leftValue.compareTo(rightValue) <= 0;
+        }
+
+        @Override
+        public Term<Boolean> doSubstitute(Substitution substitution, Term<T> substitutedLeft, Term<T> substitutedRight) {
+                return new LessEqTerm<>(getArgumentType(), substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        public String toString() {
+                return "(%s <= %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/LessTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/LessTerm.java
new file mode 100644
index 00000000..44e70902
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/LessTerm.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.comparable;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class LessTerm<T extends Comparable<T>> extends ComparisonTerm<T> {
+        public LessTerm(Class<T> argumentType, Term<T> left, Term<T> right) {
+                super(argumentType, left, right);
+        }
+
+        @Override
+        protected Boolean doEvaluate(T leftValue, T rightValue) {
+                return leftValue.compareTo(rightValue) < 0;
+        }
+
+        @Override
+        public Term<Boolean> doSubstitute(Substitution substitution, Term<T> substitutedLeft, Term<T> substitutedRight) {
+                return new LessTerm<>(getArgumentType(), substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        public String toString() {
+                return "(%s < %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/NotEqTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/NotEqTerm.java
new file mode 100644
index 00000000..1f9734c4
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/comparable/NotEqTerm.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.comparable;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class NotEqTerm<T> extends ComparisonTerm<T> {
+        public NotEqTerm(Class<T> argumentType, Term<T> left, Term<T> right) {
+                super(argumentType, left, right);
+        }
+
+        @Override
+        protected Boolean doEvaluate(T leftValue, T rightValue) {
+                return !leftValue.equals(rightValue);
+        }
+
+        @Override
+        public Term<Boolean> doSubstitute(Substitution substitution, Term<T> substitutedLeft, Term<T> substitutedRight) {
+                return new NotEqTerm<>(getArgumentType(), substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        public String toString() {
+                return "(%s != %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntAddTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntAddTerm.java
new file mode 100644
index 00000000..dbea3efc
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntAddTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class IntAddTerm extends IntBinaryTerm {
+        public IntAddTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                                                          Term<Integer> substitutedRight) {
+                return new IntAddTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return leftValue + rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s + %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntBinaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntBinaryTerm.java
new file mode 100644
index 00000000..27ced4e4
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntBinaryTerm.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.term.BinaryTerm;
+import tools.refinery.store.query.term.Term;
+
+public abstract class IntBinaryTerm extends BinaryTerm<Integer, Integer, Integer> {
+        protected IntBinaryTerm(Term<Integer> left, Term<Integer> right) {
+                super(Integer.class, Integer.class, Integer.class, left, right);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntDivTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntDivTerm.java
new file mode 100644
index 00000000..2a35058c
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntDivTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class IntDivTerm extends IntBinaryTerm {
+        public IntDivTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                                                          Term<Integer> substitutedRight) {
+                return new IntDivTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return rightValue == 0 ? null : leftValue / rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s / %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntMaxTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntMaxTerm.java
new file mode 100644
index 00000000..f81fc509
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntMaxTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class IntMaxTerm extends IntBinaryTerm {
+        public IntMaxTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                                                          Term<Integer> substitutedRight) {
+                return new IntMaxTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return Math.max(rightValue, leftValue);
+        }
+
+        @Override
+        public String toString() {
+                return "max(%s, %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntMinTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntMinTerm.java
new file mode 100644
index 00000000..89182e26
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntMinTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class IntMinTerm extends IntBinaryTerm {
+        public IntMinTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                                                          Term<Integer> substitutedRight) {
+                return new IntMinTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return Math.min(rightValue, leftValue);
+        }
+
+        @Override
+        public String toString() {
+                return "min(%s, %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntMinusTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntMinusTerm.java
new file mode 100644
index 00000000..709aa5ba
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntMinusTerm.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class IntMinusTerm extends IntUnaryTerm {
+        public IntMinusTerm(Term<Integer> body) {
+                super(body);
+        }
+
+        @Override
+        protected Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedBody) {
+                return new IntMinusTerm(substitutedBody);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer bodyValue) {
+                return -bodyValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(-%s)".formatted(getBody());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntMulTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntMulTerm.java
new file mode 100644
index 00000000..89d4c5f4
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntMulTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class IntMulTerm extends IntBinaryTerm {
+        public IntMulTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                                                          Term<Integer> substitutedRight) {
+                return new IntMulTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return leftValue * rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s * %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntPlusTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntPlusTerm.java
new file mode 100644
index 00000000..aef83bb4
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntPlusTerm.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class IntPlusTerm extends IntUnaryTerm {
+        public IntPlusTerm(Term<Integer> body) {
+                super(body);
+        }
+
+        @Override
+        protected Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedBody) {
+                return new IntPlusTerm(substitutedBody);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer bodyValue) {
+                return bodyValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(+%s)".formatted(getBody());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntPowTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntPowTerm.java
new file mode 100644
index 00000000..d5af97a1
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntPowTerm.java
@@ -0,0 +1,43 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class IntPowTerm extends IntBinaryTerm {
+        public IntPowTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                                                          Term<Integer> substitutedRight) {
+                return new IntPowTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return rightValue < 0 ? null : power(leftValue, rightValue);
+        }
+
+        private static int power(int base, int exponent) {
+                int accum = 1;
+                while (exponent > 0) {
+                        if (exponent % 2 == 1) {
+                                accum = accum * base;
+                        }
+                        base = base * base;
+                        exponent = exponent / 2;
+                }
+                return accum;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s ** %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntSubTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntSubTerm.java
new file mode 100644
index 00000000..2c27afb1
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntSubTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class IntSubTerm extends IntBinaryTerm {
+        public IntSubTerm(Term<Integer> left, Term<Integer> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                                                          Term<Integer> substitutedRight) {
+                return new IntSubTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return leftValue - rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s - %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntSumAggregator.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntSumAggregator.java
new file mode 100644
index 00000000..cd718c53
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntSumAggregator.java
@@ -0,0 +1,40 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.term.StatelessAggregator;
+
+public final class IntSumAggregator implements StatelessAggregator<Integer, Integer> {
+        public static final IntSumAggregator INSTANCE = new IntSumAggregator();
+
+        private IntSumAggregator() {
+        }
+
+        @Override
+        public Class<Integer> getResultType() {
+                return Integer.class;
+        }
+
+        @Override
+        public Class<Integer> getInputType() {
+                return Integer.class;
+        }
+
+        @Override
+        public Integer getEmptyResult() {
+                return 0;
+        }
+
+        @Override
+        public Integer add(Integer current, Integer value) {
+                return current + value;
+        }
+
+        @Override
+        public Integer remove(Integer current, Integer value) {
+                return current - value;
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntTerms.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntTerms.java
new file mode 100644
index 00000000..acb98b94
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntTerms.java
@@ -0,0 +1,94 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.term.Aggregator;
+import tools.refinery.store.query.term.ConstantTerm;
+import tools.refinery.store.query.term.ExtremeValueAggregator;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.query.term.comparable.*;
+
+import java.util.Comparator;
+
+public final class IntTerms {
+        public static final Aggregator<Integer, Integer> INT_SUM = IntSumAggregator.INSTANCE;
+        public static final Aggregator<Integer, Integer> INT_MIN = new ExtremeValueAggregator<>(Integer.class,
+                        Integer.MAX_VALUE);
+        public static final Aggregator<Integer, Integer> INT_MAX = new ExtremeValueAggregator<>(Integer.class,
+                        Integer.MIN_VALUE, Comparator.reverseOrder());
+
+        private IntTerms() {
+                throw new IllegalArgumentException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static Term<Integer> constant(Integer value) {
+                return new ConstantTerm<>(Integer.class, value);
+        }
+
+        public static Term<Integer> plus(Term<Integer> body) {
+                return new IntPlusTerm(body);
+        }
+
+        public static Term<Integer> minus(Term<Integer> body) {
+                return new IntMinusTerm(body);
+        }
+
+        public static Term<Integer> add(Term<Integer> left, Term<Integer> right) {
+                return new IntAddTerm(left, right);
+        }
+
+        public static Term<Integer> sub(Term<Integer> left, Term<Integer> right) {
+                return new IntSubTerm(left, right);
+        }
+
+        public static Term<Integer> mul(Term<Integer> left, Term<Integer> right) {
+                return new IntMulTerm(left, right);
+        }
+
+        public static Term<Integer> div(Term<Integer> left, Term<Integer> right) {
+                return new IntDivTerm(left, right);
+        }
+
+        public static Term<Integer> pow(Term<Integer> left, Term<Integer> right) {
+                return new IntPowTerm(left, right);
+        }
+
+        public static Term<Integer> min(Term<Integer> left, Term<Integer> right) {
+                return new IntMinTerm(left, right);
+        }
+
+        public static Term<Integer> max(Term<Integer> left, Term<Integer> right) {
+                return new IntMaxTerm(left, right);
+        }
+
+        public static Term<Boolean> eq(Term<Integer> left, Term<Integer> right) {
+                return new EqTerm<>(Integer.class, left, right);
+        }
+
+        public static Term<Boolean> notEq(Term<Integer> left, Term<Integer> right) {
+                return new NotEqTerm<>(Integer.class, left, right);
+        }
+
+        public static Term<Boolean> less(Term<Integer> left, Term<Integer> right) {
+                return new LessTerm<>(Integer.class, left, right);
+        }
+
+        public static Term<Boolean> lessEq(Term<Integer> left, Term<Integer> right) {
+                return new LessEqTerm<>(Integer.class, left, right);
+        }
+
+        public static Term<Boolean> greater(Term<Integer> left, Term<Integer> right) {
+                return new GreaterTerm<>(Integer.class, left, right);
+        }
+
+        public static Term<Boolean> greaterEq(Term<Integer> left, Term<Integer> right) {
+                return new GreaterEqTerm<>(Integer.class, left, right);
+        }
+
+        public static Term<Integer> asInt(Term<Double> body) {
+                return new RealToIntTerm(body);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntUnaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntUnaryTerm.java
new file mode 100644
index 00000000..49b4c647
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntUnaryTerm.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.query.term.UnaryTerm;
+
+public abstract class IntUnaryTerm extends UnaryTerm<Integer, Integer> {
+        protected IntUnaryTerm(Term<Integer> body) {
+                super(Integer.class, Integer.class, body);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/RealToIntTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/RealToIntTerm.java
new file mode 100644
index 00000000..7d383562
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/RealToIntTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.query.term.UnaryTerm;
+
+public class RealToIntTerm extends UnaryTerm<Integer, Double> {
+        protected RealToIntTerm(Term<Double> body) {
+                super(Integer.class, Double.class, body);
+        }
+
+        @Override
+        protected Integer doEvaluate(Double bodyValue) {
+                return bodyValue.isNaN() ? null : bodyValue.intValue();
+        }
+
+        @Override
+        protected Term<Integer> doSubstitute(Substitution substitution, Term<Double> substitutedBody) {
+                return new RealToIntTerm(substitutedBody);
+        }
+
+        @Override
+        public String toString() {
+                return "(%s as int)".formatted(getBody());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/IntToRealTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/IntToRealTerm.java
new file mode 100644
index 00000000..2f53117a
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/IntToRealTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.query.term.UnaryTerm;
+
+public class IntToRealTerm extends UnaryTerm<Double, Integer> {
+        protected IntToRealTerm(Term<Integer> body) {
+                super(Double.class, Integer.class, body);
+        }
+
+        @Override
+        protected Term<Double> doSubstitute(Substitution substitution, Term<Integer> substitutedBody) {
+                return new IntToRealTerm(substitutedBody);
+        }
+
+        @Override
+        protected Double doEvaluate(Integer bodyValue) {
+                return bodyValue.doubleValue();
+        }
+
+        @Override
+        public String toString() {
+                return "(%s as real)".formatted(getBody());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealAddTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealAddTerm.java
new file mode 100644
index 00000000..33fc9e41
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealAddTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class RealAddTerm extends RealBinaryTerm {
+        public RealAddTerm(Term<Double> left, Term<Double> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Double> doSubstitute(Substitution substitution, Term<Double> substitutedLeft,
+                                                                         Term<Double> substitutedRight) {
+                return new RealAddTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Double doEvaluate(Double leftValue, Double rightValue) {
+                return leftValue + rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s + %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealBinaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealBinaryTerm.java
new file mode 100644
index 00000000..000f3623
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealBinaryTerm.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.term.BinaryTerm;
+import tools.refinery.store.query.term.Term;
+
+public abstract class RealBinaryTerm extends BinaryTerm<Double, Double, Double> {
+        protected RealBinaryTerm(Term<Double> left, Term<Double> right) {
+                super(Double.class, Double.class, Double.class, left, right);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealDivTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealDivTerm.java
new file mode 100644
index 00000000..1e55bf42
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealDivTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class RealDivTerm extends RealBinaryTerm {
+        public RealDivTerm(Term<Double> left, Term<Double> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Double> doSubstitute(Substitution substitution, Term<Double> substitutedLeft,
+                                                                         Term<Double> substitutedRight) {
+                return new RealDivTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Double doEvaluate(Double leftValue, Double rightValue) {
+                return leftValue / rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s / %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealMaxTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealMaxTerm.java
new file mode 100644
index 00000000..2a249496
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealMaxTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class RealMaxTerm extends RealBinaryTerm {
+        public RealMaxTerm(Term<Double> left, Term<Double> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Double> doSubstitute(Substitution substitution, Term<Double> substitutedLeft,
+                                                                         Term<Double> substitutedRight) {
+                return new RealMaxTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Double doEvaluate(Double leftValue, Double rightValue) {
+                return Math.max(leftValue, rightValue);
+        }
+
+        @Override
+        public String toString() {
+                return "max(%s, %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealMinTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealMinTerm.java
new file mode 100644
index 00000000..2eb4cc1e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealMinTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class RealMinTerm extends RealBinaryTerm {
+        public RealMinTerm(Term<Double> left, Term<Double> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Double> doSubstitute(Substitution substitution, Term<Double> substitutedLeft,
+                                                                         Term<Double> substitutedRight) {
+                return new RealMinTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Double doEvaluate(Double leftValue, Double rightValue) {
+                return Math.min(leftValue, rightValue);
+        }
+
+        @Override
+        public String toString() {
+                return "min(%s, %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealMinusTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealMinusTerm.java
new file mode 100644
index 00000000..4afec7a1
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealMinusTerm.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class RealMinusTerm extends RealUnaryTerm {
+        public RealMinusTerm(Term<Double> body) {
+                super(body);
+        }
+
+        @Override
+        protected Term<Double> doSubstitute(Substitution substitution, Term<Double> substitutedBody) {
+                return new RealMinusTerm(substitutedBody);
+        }
+
+        @Override
+        protected Double doEvaluate(Double bodyValue) {
+                return -bodyValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(-%s)".formatted(getBody());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealMulTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealMulTerm.java
new file mode 100644
index 00000000..ec95ac6f
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealMulTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class RealMulTerm extends RealBinaryTerm {
+        public RealMulTerm(Term<Double> left, Term<Double> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Double> doSubstitute(Substitution substitution, Term<Double> substitutedLeft,
+                                                                         Term<Double> substitutedRight) {
+                return new RealMulTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Double doEvaluate(Double leftValue, Double rightValue) {
+                return leftValue * rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s * %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealPlusTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealPlusTerm.java
new file mode 100644
index 00000000..64dd2e70
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealPlusTerm.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class RealPlusTerm extends RealUnaryTerm {
+        public RealPlusTerm(Term<Double> body) {
+                super(body);
+        }
+
+        @Override
+        protected Term<Double> doSubstitute(Substitution substitution, Term<Double> substitutedBody) {
+                return new RealPlusTerm(substitutedBody);
+        }
+
+        @Override
+        protected Double doEvaluate(Double bodyValue) {
+                return bodyValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(+%s)".formatted(getBody());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealPowTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealPowTerm.java
new file mode 100644
index 00000000..11c952ea
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealPowTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class RealPowTerm extends RealBinaryTerm {
+        public RealPowTerm(Term<Double> left, Term<Double> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Double> doSubstitute(Substitution substitution, Term<Double> substitutedLeft,
+                                                                         Term<Double> substitutedRight) {
+                return new RealPowTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Double doEvaluate(Double leftValue, Double rightValue) {
+                return Math.pow(leftValue, rightValue);
+        }
+
+        @Override
+        public String toString() {
+                return "(%s ** %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealSubTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealSubTerm.java
new file mode 100644
index 00000000..8cc701ed
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealSubTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+
+public class RealSubTerm extends RealBinaryTerm {
+        public RealSubTerm(Term<Double> left, Term<Double> right) {
+                super(left, right);
+        }
+
+        @Override
+        public Term<Double> doSubstitute(Substitution substitution, Term<Double> substitutedLeft,
+                                                                         Term<Double> substitutedRight) {
+                return new RealSubTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Double doEvaluate(Double leftValue, Double rightValue) {
+                return leftValue - rightValue;
+        }
+
+        @Override
+        public String toString() {
+                return "(%s - %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealSumAggregator.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealSumAggregator.java
new file mode 100644
index 00000000..d21048e9
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealSumAggregator.java
@@ -0,0 +1,90 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.term.StatefulAggregate;
+import tools.refinery.store.query.term.StatefulAggregator;
+
+import java.util.Map;
+import java.util.TreeMap;
+
+public final class RealSumAggregator implements StatefulAggregator<Double, Double> {
+        public static final RealSumAggregator INSTANCE = new RealSumAggregator();
+
+        private RealSumAggregator() {
+        }
+
+        @Override
+        public Class<Double> getResultType() {
+                return Double.class;
+        }
+
+        @Override
+        public Class<Double> getInputType() {
+                return Double.class;
+        }
+
+        @Override
+        public StatefulAggregate<Double, Double> createEmptyAggregate() {
+                return new Aggregate();
+        }
+
+        @Override
+        public Double getEmptyResult() {
+                return 0d;
+        }
+
+        private static class Aggregate implements StatefulAggregate<Double, Double> {
+                private final Map<Double, Integer> values;
+
+                public Aggregate() {
+                        values = new TreeMap<>();
+                }
+
+                private Aggregate(Aggregate other) {
+                        values = new TreeMap<>(other.values);
+                }
+
+                @Override
+                public void add(Double value) {
+                        values.compute(value, (ignoredValue, currentCount) -> currentCount == null ? 1 : currentCount + 1);
+                }
+
+                @Override
+                public void remove(Double value) {
+                        values.compute(value, (theValue, currentCount) -> {
+                                if (currentCount == null || currentCount <= 0) {
+                                        throw new IllegalStateException("Invalid count %d for value %f".formatted(currentCount, theValue));
+                                }
+                                return currentCount.equals(1) ? null : currentCount - 1;
+                        });
+                }
+
+                @Override
+                public Double getResult() {
+                        return values.entrySet()
+                                        .stream()
+                                        .mapToDouble(entry -> entry.getKey() * entry.getValue())
+                                        .reduce(Double::sum)
+                                        .orElse(0d);
+                }
+
+                @Override
+                public boolean isEmpty() {
+                        return values.isEmpty();
+                }
+
+                @Override
+                public StatefulAggregate<Double, Double> deepCopy() {
+                        return new Aggregate(this);
+                }
+
+                @Override
+                public boolean contains(Double value) {
+                        return values.containsKey(value);
+                }
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealTerms.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealTerms.java
new file mode 100644
index 00000000..79220358
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealTerms.java
@@ -0,0 +1,94 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.term.Aggregator;
+import tools.refinery.store.query.term.ConstantTerm;
+import tools.refinery.store.query.term.ExtremeValueAggregator;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.query.term.comparable.*;
+
+import java.util.Comparator;
+
+public final class RealTerms {
+        public static final Aggregator<Double, Double> REAL_SUM = RealSumAggregator.INSTANCE;
+        public static final Aggregator<Double, Double> REAL_MIN = new ExtremeValueAggregator<>(Double.class,
+                        Double.POSITIVE_INFINITY);
+        public static final Aggregator<Double, Double> REAL_MAX = new ExtremeValueAggregator<>(Double.class,
+                        Double.NEGATIVE_INFINITY, Comparator.reverseOrder());
+
+        private RealTerms() {
+                throw new IllegalArgumentException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static Term<Double> constant(Double value) {
+                return new ConstantTerm<>(Double.class, value);
+        }
+
+        public static Term<Double> plus(Term<Double> body) {
+                return new RealPlusTerm(body);
+        }
+
+        public static Term<Double> minus(Term<Double> body) {
+                return new RealMinusTerm(body);
+        }
+
+        public static Term<Double> add(Term<Double> left, Term<Double> right) {
+                return new RealAddTerm(left, right);
+        }
+
+        public static Term<Double> sub(Term<Double> left, Term<Double> right) {
+                return new RealSubTerm(left, right);
+        }
+
+        public static Term<Double> mul(Term<Double> left, Term<Double> right) {
+                return new RealMulTerm(left, right);
+        }
+
+        public static Term<Double> div(Term<Double> left, Term<Double> right) {
+                return new RealDivTerm(left, right);
+        }
+
+        public static Term<Double> pow(Term<Double> left, Term<Double> right) {
+                return new RealPowTerm(left, right);
+        }
+
+        public static Term<Double> min(Term<Double> left, Term<Double> right) {
+                return new RealMinTerm(left, right);
+        }
+
+        public static Term<Double> max(Term<Double> left, Term<Double> right) {
+                return new RealMaxTerm(left, right);
+        }
+
+        public static Term<Boolean> eq(Term<Double> left, Term<Double> right) {
+                return new EqTerm<>(Double.class, left, right);
+        }
+
+        public static Term<Boolean> notEq(Term<Double> left, Term<Double> right) {
+                return new NotEqTerm<>(Double.class, left, right);
+        }
+
+        public static Term<Boolean> less(Term<Double> left, Term<Double> right) {
+                return new LessTerm<>(Double.class, left, right);
+        }
+
+        public static Term<Boolean> lessEq(Term<Double> left, Term<Double> right) {
+                return new LessEqTerm<>(Double.class, left, right);
+        }
+
+        public static Term<Boolean> greater(Term<Double> left, Term<Double> right) {
+                return new GreaterTerm<>(Double.class, left, right);
+        }
+
+        public static Term<Boolean> greaterEq(Term<Double> left, Term<Double> right) {
+                return new GreaterEqTerm<>(Double.class, left, right);
+        }
+
+        public static Term<Double> asReal(Term<Integer> body) {
+                return new IntToRealTerm(body);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealUnaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealUnaryTerm.java
new file mode 100644
index 00000000..d41c4ed9
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealUnaryTerm.java
@@ -0,0 +1,15 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.query.term.UnaryTerm;
+
+public abstract class RealUnaryTerm extends UnaryTerm<Double, Double> {
+        protected RealUnaryTerm(Term<Double> body) {
+                super(Double.class, Double.class, body);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityAddTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityAddTerm.java
new file mode 100644
index 00000000..68905f51
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityAddTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.uppercardinality;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.representation.cardinality.UpperCardinality;
+
+public class UpperCardinalityAddTerm extends UpperCardinalityBinaryTerm {
+        protected UpperCardinalityAddTerm(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                super(left, right);
+        }
+
+        @Override
+        protected UpperCardinality doEvaluate(UpperCardinality leftValue, UpperCardinality rightValue) {
+                return leftValue.add(rightValue);
+        }
+
+        @Override
+        public Term<UpperCardinality> doSubstitute(Substitution substitution, Term<UpperCardinality> substitutedLeft, Term<UpperCardinality> substitutedRight) {
+                return new UpperCardinalityAddTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        public String toString() {
+                return "(%s + %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityBinaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityBinaryTerm.java
new file mode 100644
index 00000000..0cf8fe44
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityBinaryTerm.java
@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.uppercardinality;
+
+import tools.refinery.store.query.term.BinaryTerm;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.representation.cardinality.UpperCardinality;
+
+public abstract class UpperCardinalityBinaryTerm extends BinaryTerm<UpperCardinality, UpperCardinality,
+                UpperCardinality> {
+        protected UpperCardinalityBinaryTerm(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                super(UpperCardinality.class, UpperCardinality.class, UpperCardinality.class, left, right);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityMaxTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityMaxTerm.java
new file mode 100644
index 00000000..ff75f64e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityMaxTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.uppercardinality;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.representation.cardinality.UpperCardinality;
+
+public class UpperCardinalityMaxTerm extends UpperCardinalityBinaryTerm {
+        protected UpperCardinalityMaxTerm(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                super(left, right);
+        }
+
+        @Override
+        protected UpperCardinality doEvaluate(UpperCardinality leftValue, UpperCardinality rightValue) {
+                return leftValue.max(rightValue);
+        }
+
+        @Override
+        public Term<UpperCardinality> doSubstitute(Substitution substitution, Term<UpperCardinality> substitutedLeft, Term<UpperCardinality> substitutedRight) {
+                return new UpperCardinalityMaxTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        public String toString() {
+                return "max(%s, %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityMinTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityMinTerm.java
new file mode 100644
index 00000000..1e89e9f4
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityMinTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.uppercardinality;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.representation.cardinality.UpperCardinality;
+
+public class UpperCardinalityMinTerm extends UpperCardinalityBinaryTerm {
+        protected UpperCardinalityMinTerm(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                super(left, right);
+        }
+
+        @Override
+        protected UpperCardinality doEvaluate(UpperCardinality leftValue, UpperCardinality rightValue) {
+                return leftValue.min(rightValue);
+        }
+
+        @Override
+        public Term<UpperCardinality> doSubstitute(Substitution substitution, Term<UpperCardinality> substitutedLeft, Term<UpperCardinality> substitutedRight) {
+                return new UpperCardinalityMinTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        public String toString() {
+                return "min(%s, %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityMulTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityMulTerm.java
new file mode 100644
index 00000000..3b4970f4
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityMulTerm.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.uppercardinality;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.representation.cardinality.UpperCardinality;
+
+public class UpperCardinalityMulTerm extends UpperCardinalityBinaryTerm {
+        protected UpperCardinalityMulTerm(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                super(left, right);
+        }
+
+        @Override
+        protected UpperCardinality doEvaluate(UpperCardinality leftValue, UpperCardinality rightValue) {
+                return leftValue.multiply(rightValue);
+        }
+
+        @Override
+        public Term<UpperCardinality> doSubstitute(Substitution substitution, Term<UpperCardinality> substitutedLeft, Term<UpperCardinality> substitutedRight) {
+                return new UpperCardinalityMulTerm(substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        public String toString() {
+                return "(%s * %s)".formatted(getLeft(), getRight());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalitySumAggregator.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalitySumAggregator.java
new file mode 100644
index 00000000..5bbd3081
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalitySumAggregator.java
@@ -0,0 +1,86 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.uppercardinality;
+
+import tools.refinery.store.query.term.StatefulAggregate;
+import tools.refinery.store.query.term.StatefulAggregator;
+import tools.refinery.store.representation.cardinality.FiniteUpperCardinality;
+import tools.refinery.store.representation.cardinality.UnboundedUpperCardinality;
+import tools.refinery.store.representation.cardinality.UpperCardinalities;
+import tools.refinery.store.representation.cardinality.UpperCardinality;
+
+public class UpperCardinalitySumAggregator implements StatefulAggregator<UpperCardinality, UpperCardinality> {
+        public static final UpperCardinalitySumAggregator INSTANCE = new UpperCardinalitySumAggregator();
+
+        private UpperCardinalitySumAggregator() {
+        }
+
+        @Override
+        public Class<UpperCardinality> getResultType() {
+                return UpperCardinality.class;
+        }
+
+        @Override
+        public Class<UpperCardinality> getInputType() {
+                return UpperCardinality.class;
+        }
+
+        @Override
+        public StatefulAggregate<UpperCardinality, UpperCardinality> createEmptyAggregate() {
+                return new Aggregate();
+        }
+
+        private static class Aggregate implements StatefulAggregate<UpperCardinality, UpperCardinality> {
+                private int sumFiniteUpperBounds;
+                private int countUnbounded;
+
+                public Aggregate() {
+                        this(0, 0);
+                }
+
+                private Aggregate(int sumFiniteUpperBounds, int countUnbounded) {
+                        this.sumFiniteUpperBounds = sumFiniteUpperBounds;
+                        this.countUnbounded = countUnbounded;
+                }
+
+                @Override
+                public void add(UpperCardinality value) {
+                        if (value instanceof FiniteUpperCardinality finiteUpperCardinality) {
+                                sumFiniteUpperBounds += finiteUpperCardinality.finiteUpperBound();
+                        } else if (value instanceof UnboundedUpperCardinality) {
+                                countUnbounded += 1;
+                        } else {
+                                throw new IllegalArgumentException("Unknown UpperCardinality: " + value);
+                        }
+                }
+
+                @Override
+                public void remove(UpperCardinality value) {
+                        if (value instanceof FiniteUpperCardinality finiteUpperCardinality) {
+                                sumFiniteUpperBounds -= finiteUpperCardinality.finiteUpperBound();
+                        } else if (value instanceof UnboundedUpperCardinality) {
+                                countUnbounded -= 1;
+                        } else {
+                                throw new IllegalArgumentException("Unknown UpperCardinality: " + value);
+                        }
+                }
+
+                @Override
+                public UpperCardinality getResult() {
+                        return countUnbounded > 0 ? UpperCardinalities.UNBOUNDED : UpperCardinalities.valueOf(sumFiniteUpperBounds);
+                }
+
+                @Override
+                public boolean isEmpty() {
+                        return sumFiniteUpperBounds == 0 && countUnbounded == 0;
+                }
+
+                @Override
+                public StatefulAggregate<UpperCardinality, UpperCardinality> deepCopy() {
+                        return new Aggregate(sumFiniteUpperBounds, countUnbounded);
+                }
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityTerms.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityTerms.java
new file mode 100644
index 00000000..13914f2d
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/uppercardinality/UpperCardinalityTerms.java
@@ -0,0 +1,73 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.term.uppercardinality;
+
+import tools.refinery.store.query.term.Aggregator;
+import tools.refinery.store.query.term.ConstantTerm;
+import tools.refinery.store.query.term.ExtremeValueAggregator;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.query.term.comparable.*;
+import tools.refinery.store.representation.cardinality.UpperCardinalities;
+import tools.refinery.store.representation.cardinality.UpperCardinality;
+
+import java.util.Comparator;
+
+public final class UpperCardinalityTerms {
+        public static final Aggregator<UpperCardinality, UpperCardinality> UPPER_CARDINALITY_SUM =
+                        UpperCardinalitySumAggregator.INSTANCE;
+        public static final Aggregator<UpperCardinality, UpperCardinality> UPPER_CARDINALITY_MIN =
+                        new ExtremeValueAggregator<>(UpperCardinality.class, UpperCardinalities.UNBOUNDED);
+        public static final Aggregator<UpperCardinality, UpperCardinality> UPPER_CARDINALITY_MAX =
+                        new ExtremeValueAggregator<>(UpperCardinality.class, UpperCardinalities.ZERO, Comparator.reverseOrder());
+
+        private UpperCardinalityTerms() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static Term<UpperCardinality> constant(UpperCardinality value) {
+                return new ConstantTerm<>(UpperCardinality.class, value);
+        }
+
+        public static Term<UpperCardinality> add(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                return new UpperCardinalityAddTerm(left, right);
+        }
+
+        public static Term<UpperCardinality> mul(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                return new UpperCardinalityMulTerm(left, right);
+        }
+
+        public static Term<UpperCardinality> min(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                return new UpperCardinalityMinTerm(left, right);
+        }
+
+        public static Term<UpperCardinality> max(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                return new UpperCardinalityMaxTerm(left, right);
+        }
+
+        public static Term<Boolean> eq(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                return new EqTerm<>(UpperCardinality.class, left, right);
+        }
+
+        public static Term<Boolean> notEq(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                return new NotEqTerm<>(UpperCardinality.class, left, right);
+        }
+
+        public static Term<Boolean> less(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                return new LessTerm<>(UpperCardinality.class, left, right);
+        }
+
+        public static Term<Boolean> lessEq(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                return new LessEqTerm<>(UpperCardinality.class, left, right);
+        }
+
+        public static Term<Boolean> greater(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                return new GreaterTerm<>(UpperCardinality.class, left, right);
+        }
+
+        public static Term<Boolean> greaterEq(Term<UpperCardinality> left, Term<UpperCardinality> right) {
+                return new GreaterEqTerm<>(UpperCardinality.class, left, right);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/utils/OrderStatisticTree.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/utils/OrderStatisticTree.java
new file mode 100644
index 00000000..b568b99d
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/utils/OrderStatisticTree.java
@@ -0,0 +1,754 @@
+/*
+ * Copyright (c) 2021 Rodion Efremov
+ * Copyright (c) 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: MIT OR EPL-2.0
+ */
+package tools.refinery.store.query.utils;
+
+import java.util.*;
+
+/**
+ * This class implements an order statistic tree which is based on AVL-trees.
+ * <p>
+ * This class was copied into <i>Refinery</i> from
+ * <a href="https://github.com/coderodde/OrderStatisticTree/tree/546c343b9f5d868e394a079ff32691c9dbfd83e3">https://github.com/coderodde/OrderStatisticTree</a>
+ * and is available under the
+ * <a href="https://github.com/coderodde/OrderStatisticTree/blob/master/LICENSE">MIT License</a>.
+ * We also incorporated changes by <a href="https://github.com/coderodde/OrderStatisticTree/issues/3">Eugene Schava</a>
+ * and cleaned up some linter warnings.
+ *
+ * @param <T> the actual element type.
+ * @author Rodion "rodde" Efremov
+ * @version based on 1.6 (Feb 11, 2016)
+ */
+public class OrderStatisticTree<T extends Comparable<? super T>> implements Set<T> {
+
+        @Override
+        public Iterator<T> iterator() {
+                return new TreeIterator();
+        }
+
+        private final class TreeIterator implements Iterator<T> {
+
+                private Node<T> previousNode;
+                private Node<T> nextNode;
+                private int expectedModCount = modCount;
+
+                TreeIterator() {
+                        if (root == null) {
+                                nextNode = null;
+                        } else {
+                                nextNode = minimumNode(root);
+                        }
+                }
+
+                @Override
+                public boolean hasNext() {
+                        return nextNode != null;
+                }
+
+                @Override
+                public T next() {
+                        if (nextNode == null) {
+                                throw new NoSuchElementException("Iteration exceeded.");
+                        }
+
+                        checkConcurrentModification();
+                        T datum = nextNode.key;
+                        previousNode = nextNode;
+                        nextNode = successorOf(nextNode);
+                        return datum;
+                }
+
+                @Override
+                public void remove() {
+                        if (previousNode == null) {
+                                throw new IllegalStateException(
+                                                nextNode == null ?
+                                                                "Not a single call to next(); nothing to remove." :
+                                                                "Removing the same element twice."
+                                );
+                        }
+
+                        checkConcurrentModification();
+
+                        Node<T> x = deleteNode(previousNode);
+                        fixAfterModification(x, false);
+
+                        if (x == nextNode) {
+                                nextNode = previousNode;
+                        }
+
+                        expectedModCount = ++modCount;
+                        size--;
+                        previousNode = null;
+                }
+
+                private void checkConcurrentModification() {
+                        if (expectedModCount != modCount) {
+                                throw new ConcurrentModificationException(
+                                                "The set was modified while iterating.");
+                        }
+                }
+
+                private Node<T> successorOf(Node<T> node) {
+                        if (node.right != null) {
+                                node = node.right;
+
+                                while (node.left != null) {
+                                        node = node.left;
+                                }
+
+                                return node;
+                        }
+
+                        Node<T> parent = node.parent;
+
+                        while (parent != null && parent.right == node) {
+                                node = parent;
+                                parent = parent.parent;
+                        }
+
+                        return parent;
+                }
+        }
+
+        @Override
+        public Object[] toArray() {
+                Object[] array = new Object[size];
+                Iterator<T> iterator = iterator();
+                int index = 0;
+
+                while (iterator.hasNext()) {
+                        array[index++] = iterator.next();
+                }
+
+                return array;
+        }
+
+        @Override
+        public <U> U[] toArray(U[] a) {
+                Iterator<T> iterator = iterator();
+
+                if (size > a.length) {
+                        a = Arrays.copyOf(a, size);
+                }
+
+                int index = 0;
+
+                for (; index < size; ++index) {
+                        @SuppressWarnings("unchecked")
+                        var convertedValue = (U) iterator.next();
+                        a[index] = convertedValue;
+                }
+
+                if (index < a.length) {
+                        a[index] = null;
+                }
+
+                return a;
+        }
+
+        @Override
+        public boolean containsAll(Collection<?> c) {
+                for (Object element : c) {
+                        if (!contains(element)) {
+                                return false;
+                        }
+                }
+
+                return true;
+        }
+
+        @Override
+        public boolean addAll(Collection<? extends T> c) {
+                boolean modified = false;
+
+                for (T element : c) {
+                        if (add(element)) {
+                                modified = true;
+                        }
+                }
+
+                return modified;
+        }
+
+        @Override
+        public boolean retainAll(Collection<?> c) {
+                if (!c.getClass().equals(HashSet.class)) {
+                        c = new HashSet<>(c);
+                }
+
+                Iterator<T> iterator = iterator();
+                boolean modified = false;
+
+                while (iterator.hasNext()) {
+                        T element = iterator.next();
+
+                        if (!c.contains(element)) {
+                                iterator.remove();
+                                modified = true;
+                        }
+                }
+
+                return modified;
+        }
+
+        @Override
+        public boolean removeAll(Collection<?> c) {
+                boolean modified = false;
+
+                for (Object element : c) {
+                        if (remove(element)) {
+                                modified = true;
+                        }
+                }
+
+                return modified;
+        }
+
+        private static final class Node<T> {
+                T key;
+
+                Node<T> parent;
+                Node<T> left;
+                Node<T> right;
+
+                int height;
+                int count;
+
+                Node(T key) {
+                        this.key = key;
+                }
+        }
+
+        private Node<T> root;
+        private int size;
+        private int modCount;
+
+        @Override
+        public boolean add(T element) {
+                Objects.requireNonNull(element, "The input element is null.");
+
+                if (root == null) {
+                        root = new Node<>(element);
+                        size = 1;
+                        modCount++;
+                        return true;
+                }
+
+                Node<T> parent = null;
+                Node<T> node = root;
+                int cmp;
+
+                while (node != null) {
+                        cmp = element.compareTo(node.key);
+
+                        if (cmp == 0) {
+                                // The element is already in this tree.
+                                return false;
+                        }
+
+                        parent = node;
+
+                        if (cmp < 0) {
+                                node = node.left;
+                        } else {
+                                node = node.right;
+                        }
+                }
+
+                Node<T> newnode = new Node<>(element);
+
+                if (element.compareTo(parent.key) < 0) {
+                        parent.left = newnode;
+                } else {
+                        parent.right = newnode;
+                }
+
+                newnode.parent = parent;
+                size++;
+                modCount++;
+                Node<T> hi = parent;
+                Node<T> lo = newnode;
+
+                while (hi != null) {
+                        if (hi.left == lo) {
+                                hi.count++;
+                        }
+
+                        lo = hi;
+                        hi = hi.parent;
+                }
+
+                fixAfterModification(newnode, true);
+                return true;
+        }
+
+        @Override
+        public boolean contains(Object o) {
+                @SuppressWarnings("unchecked")
+                T element = (T) o;
+                Node<T> x = root;
+                int cmp;
+
+                while (x != null && (cmp = element.compareTo(x.key)) != 0) {
+                        if (cmp < 0) {
+                                x = x.left;
+                        } else {
+                                x = x.right;
+                        }
+                }
+
+                return x != null;
+        }
+
+        @Override
+        public boolean remove(Object o) {
+                @SuppressWarnings("unchecked")
+                T element = (T) o;
+                Node<T> x = root;
+                int cmp;
+
+                while (x != null && (cmp = element.compareTo(x.key)) != 0) {
+                        if (cmp < 0) {
+                                x = x.left;
+                        } else {
+                                x = x.right;
+                        }
+                }
+
+                if (x == null) {
+                        return false;
+                }
+
+                x = deleteNode(x);
+                fixAfterModification(x, false);
+                size--;
+                modCount++;
+                return true;
+        }
+
+        public T get(int index) {
+                checkIndex(index);
+                Node<T> node = root;
+
+                while (true) {
+                        if (index > node.count) {
+                                index -= node.count + 1;
+                                node = node.right;
+                        } else if (index < node.count) {
+                                node = node.left;
+                        } else {
+                                return node.key;
+                        }
+                }
+        }
+
+        public int indexOf(T element) {
+                Node<T> node = root;
+
+                if (root == null) {
+                        return -1;
+                }
+
+                int rank = root.count;
+                int cmp;
+
+                while (true) {
+                        if ((cmp = element.compareTo(node.key)) < 0) {
+                                if (node.left == null) {
+                                        return -1;
+                                }
+
+                                rank -= (node.count - node.left.count);
+                                node = node.left;
+                        } else if (cmp > 0) {
+                                if (node.right == null) {
+                                        return -1;
+                                }
+
+                                rank += 1 + node.right.count;
+                                node = node.right;
+                        } else {
+                                return rank;
+                        }
+                }
+        }
+
+        @Override
+        public int size() {
+                return size;
+        }
+
+        @Override
+        public boolean isEmpty() {
+                return size == 0;
+        }
+
+        @Override
+        public void clear() {
+                modCount += size;
+                root = null;
+                size = 0;
+        }
+
+
+        private void checkIndex(int index) {
+                if (index < 0) {
+                        throw new IndexOutOfBoundsException(
+                                        "The input index is negative: " + index);
+                }
+
+                if (index >= size) {
+                        throw new IndexOutOfBoundsException(
+                                        "The input index is too large: " + index +
+                                                        ", the size of this tree is " + size);
+                }
+        }
+
+        @SuppressWarnings("squid:S3776")
+        private Node<T> deleteNode(Node<T> node) {
+                if (node.left == null && node.right == null) {
+                        // 'node' has no children.
+                        Node<T> parent = node.parent;
+
+                        if (parent == null) {
+                                // 'node' is the root node of this tree.
+                                root = null;
+                                ++modCount;
+                                return node;
+                        }
+
+                        Node<T> lo = node;
+                        Node<T> hi = parent;
+
+                        while (hi != null) {
+                                if (hi.left == lo) {
+                                        hi.count--;
+                                }
+
+                                lo = hi;
+                                hi = hi.parent;
+                        }
+
+                        if (node == parent.left) {
+                                parent.left = null;
+                        } else {
+                                parent.right = null;
+                        }
+
+                        return node;
+                }
+
+                if (node.left != null && node.right != null) {
+                        // 'node' has both children.
+                        Node<T> successor = minimumNode(node.right);
+                        node.key = successor.key;
+                        Node<T> child = successor.right;
+                        Node<T> parent = successor.parent;
+
+                        if (parent.left == successor) {
+                                parent.left = child;
+                        } else {
+                                parent.right = child;
+                        }
+
+                        if (child != null) {
+                                child.parent = parent;
+                        }
+
+                        Node<T> lo = child;
+                        Node<T> hi = parent;
+
+                        while (hi != null) {
+                                if (hi.left == lo) {
+                                        hi.count--;
+                                }
+
+                                lo = hi;
+                                hi = hi.parent;
+                        }
+
+                        return successor;
+                }
+
+                Node<T> child;
+
+                // 'node' has only one child.
+                if (node.left != null) {
+                        child = node.left;
+                } else {
+                        child = node.right;
+                }
+
+                Node<T> parent = node.parent;
+                child.parent = parent;
+
+                if (parent == null) {
+                        root = child;
+                        return node;
+                }
+
+                if (node == parent.left) {
+                        parent.left = child;
+                } else {
+                        parent.right = child;
+                }
+
+                Node<T> hi = parent;
+                Node<T> lo = child;
+
+                while (hi != null) {
+                        if (hi.left == lo) {
+                                hi.count--;
+                        }
+
+                        lo = hi;
+                        hi = hi.parent;
+                }
+
+                return node;
+
+        }
+
+        private Node<T> minimumNode(Node<T> node) {
+                while (node.left != null) {
+                        node = node.left;
+                }
+
+                return node;
+        }
+
+        private int height(Node<T> node) {
+                return node == null ? -1 : node.height;
+        }
+
+        private Node<T> leftRotate(Node<T> node1) {
+                Node<T> node2 = node1.right;
+                node2.parent = node1.parent;
+                node1.parent = node2;
+                node1.right = node2.left;
+                node2.left = node1;
+
+                if (node1.right != null) {
+                        node1.right.parent = node1;
+                }
+
+                node1.height = Math.max(height(node1.left), height(node1.right)) + 1;
+                node2.height = Math.max(height(node2.left), height(node2.right)) + 1;
+                node2.count += node1.count + 1;
+                return node2;
+        }
+
+        private Node<T> rightRotate(Node<T> node1) {
+                Node<T> node2 = node1.left;
+                node2.parent = node1.parent;
+                node1.parent = node2;
+                node1.left = node2.right;
+                node2.right = node1;
+
+                if (node1.left != null) {
+                        node1.left.parent = node1;
+                }
+
+                node1.height = Math.max(height(node1.left), height(node1.right)) + 1;
+                node2.height = Math.max(height(node2.left), height(node2.right)) + 1;
+                node1.count -= node2.count + 1;
+                return node2;
+        }
+
+        private Node<T> rightLeftRotate(Node<T> node1) {
+                Node<T> node2 = node1.right;
+                node1.right = rightRotate(node2);
+                return leftRotate(node1);
+        }
+
+        private Node<T> leftRightRotate(Node<T> node1) {
+                Node<T> node2 = node1.left;
+                node1.left = leftRotate(node2);
+                return rightRotate(node1);
+        }
+
+        // Fixing an insertion: use insertionMode = true.
+        // Fixing a deletion: use insertionMode = false.
+        @SuppressWarnings("squid:S3776")
+        private void fixAfterModification(Node<T> node, boolean insertionMode) {
+                Node<T> parent = node.parent;
+                Node<T> grandParent;
+                Node<T> subTree;
+
+                while (parent != null) {
+                        if (height(parent.left) == height(parent.right) + 2) {
+                                grandParent = parent.parent;
+
+                                if (height(parent.left.left) >= height(parent.left.right)) {
+                                        subTree = rightRotate(parent);
+                                } else {
+                                        subTree = leftRightRotate(parent);
+                                }
+
+                                if (grandParent == null) {
+                                        root = subTree;
+                                } else if (grandParent.left == parent) {
+                                        grandParent.left = subTree;
+                                } else {
+                                        grandParent.right = subTree;
+                                }
+
+                                if (grandParent != null) {
+                                        grandParent.height = Math.max(
+                                                        height(grandParent.left),
+                                                        height(grandParent.right)) + 1;
+                                }
+
+                                if (insertionMode) {
+                                        // Whenever fixing after insertion, at most one rotation is
+                                        // required in order to maintain the balance.
+                                        return;
+                                }
+                        } else if (height(parent.right) == height(parent.left) + 2) {
+                                grandParent = parent.parent;
+
+                                if (height(parent.right.right) >= height(parent.right.left)) {
+                                        subTree = leftRotate(parent);
+                                } else {
+                                        subTree = rightLeftRotate(parent);
+                                }
+
+                                if (grandParent == null) {
+                                        root = subTree;
+                                } else if (grandParent.left == parent) {
+                                        grandParent.left = subTree;
+                                } else {
+                                        grandParent.right = subTree;
+                                }
+
+                                if (grandParent != null) {
+                                        grandParent.height =
+                                                        Math.max(height(grandParent.left),
+                                                                        height(grandParent.right)) + 1;
+                                }
+
+                                if (insertionMode) {
+                                        return;
+                                }
+                        }
+
+                        parent.height = Math.max(height(parent.left),
+                                        height(parent.right)) + 1;
+                        parent = parent.parent;
+                }
+        }
+
+        boolean isHealthy() {
+                if (root == null) {
+                        return true;
+                }
+
+                return !containsCycles()
+                                && heightsAreCorrect()
+                                && isBalanced()
+                                && isWellIndexed();
+        }
+
+        private boolean containsCycles() {
+                Set<Node<T>> visitedNodes = new HashSet<>();
+                return containsCycles(root, visitedNodes);
+        }
+
+        private boolean containsCycles(Node<T> current, Set<Node<T>> visitedNodes) {
+                if (current == null) {
+                        return false;
+                }
+
+                if (visitedNodes.contains(current)) {
+                        return true;
+                }
+
+                visitedNodes.add(current);
+
+                return containsCycles(current.left, visitedNodes)
+                                || containsCycles(current.right, visitedNodes);
+        }
+
+        private boolean heightsAreCorrect() {
+                return getHeight(root) == root.height;
+        }
+
+        private int getHeight(Node<T> node) {
+                if (node == null) {
+                        return -1;
+                }
+
+                int leftTreeHeight = getHeight(node.left);
+
+                if (leftTreeHeight == Integer.MIN_VALUE) {
+                        return Integer.MIN_VALUE;
+                }
+
+                int rightTreeHeight = getHeight(node.right);
+
+                if (rightTreeHeight == Integer.MIN_VALUE) {
+                        return Integer.MIN_VALUE;
+                }
+
+                if (node.height == Math.max(leftTreeHeight, rightTreeHeight) + 1) {
+                        return node.height;
+                }
+
+                return Integer.MIN_VALUE;
+        }
+
+        private boolean isBalanced() {
+                return isBalanced(root);
+        }
+
+        private boolean isBalanced(Node<T> node) {
+                if (node == null) {
+                        return true;
+                }
+
+                if (!isBalanced(node.left)) {
+                        return false;
+                }
+
+                if (!isBalanced(node.right)) {
+                        return false;
+                }
+
+                int leftHeight = height(node.left);
+                int rightHeight = height(node.right);
+
+                return Math.abs(leftHeight - rightHeight) < 2;
+        }
+
+        private boolean isWellIndexed() {
+                return size == count(root);
+        }
+
+        private int count(Node<T> node) {
+                if (node == null) {
+                        return 0;
+                }
+
+                int leftTreeSize = count(node.left);
+
+                if (leftTreeSize == Integer.MIN_VALUE) {
+                        return Integer.MIN_VALUE;
+                }
+
+                if (node.count != leftTreeSize) {
+                        return Integer.MIN_VALUE;
+                }
+
+                int rightTreeSize = count(node.right);
+
+                if (rightTreeSize == Integer.MIN_VALUE) {
+                        return Integer.MIN_VALUE;
+                }
+
+                return leftTreeSize + 1 + rightTreeSize;
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/MapBasedValuation.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/MapBasedValuation.java
new file mode 100644
index 00000000..261ceaa5
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/MapBasedValuation.java
@@ -0,0 +1,22 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.valuation;
+
+import tools.refinery.store.query.term.AnyDataVariable;
+import tools.refinery.store.query.term.DataVariable;
+
+import java.util.Map;
+
+record MapBasedValuation(Map<AnyDataVariable, Object> values) implements Valuation {
+        @Override
+        public <T> T getValue(DataVariable<T> variable) {
+                if (!values.containsKey(variable)) {
+                        throw new IllegalArgumentException("No value for variable %s".formatted(variable));
+                }
+                var value = values.get(variable);
+                return variable.getType().cast(value);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/RestrictedValuation.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/RestrictedValuation.java
new file mode 100644
index 00000000..fc8406aa
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/RestrictedValuation.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.valuation;
+
+import tools.refinery.store.query.term.AnyDataVariable;
+import tools.refinery.store.query.term.DataVariable;
+
+import java.util.Set;
+
+public record RestrictedValuation(Valuation valuation, Set<AnyDataVariable> allowedVariables) implements Valuation {
+        @Override
+        public <T> T getValue(DataVariable<T> variable) {
+                if (!allowedVariables.contains(variable)) {
+                        throw new IllegalArgumentException("Variable %s is not in scope".formatted(variable));
+                }
+                return valuation.getValue(variable);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/SubstitutedValuation.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/SubstitutedValuation.java
new file mode 100644
index 00000000..1c14112c
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/SubstitutedValuation.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.valuation;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.DataVariable;
+
+public record SubstitutedValuation(Valuation originalValuation, Substitution substitution) implements Valuation {
+        @Override
+        public <T> T getValue(DataVariable<T> variable) {
+                return originalValuation.getValue(substitution.getTypeSafeSubstitute(variable));
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/Valuation.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/Valuation.java
new file mode 100644
index 00000000..1588e957
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/Valuation.java
@@ -0,0 +1,37 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.valuation;
+
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.AnyDataVariable;
+import tools.refinery.store.query.term.DataVariable;
+
+import java.util.Map;
+import java.util.Set;
+
+public interface Valuation {
+        <T> T getValue(DataVariable<T> variable);
+
+        default Valuation substitute(@Nullable Substitution substitution) {
+                if (substitution == null) {
+                        return this;
+                }
+                return new SubstitutedValuation(this, substitution);
+        }
+
+        default Valuation restrict(Set<? extends AnyDataVariable> allowedVariables) {
+                return new RestrictedValuation(this, Set.copyOf(allowedVariables));
+        }
+
+        static ValuationBuilder builder() {
+                return new ValuationBuilder();
+        }
+
+        static Valuation empty() {
+                return new MapBasedValuation(Map.of());
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/ValuationBuilder.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/ValuationBuilder.java
new file mode 100644
index 00000000..7337dbc3
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/ValuationBuilder.java
@@ -0,0 +1,40 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.valuation;
+
+import tools.refinery.store.query.term.AnyDataVariable;
+import tools.refinery.store.query.term.DataVariable;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ValuationBuilder {
+        private final Map<AnyDataVariable, Object> values = new HashMap<>();
+
+        ValuationBuilder() {
+        }
+
+        public <T> ValuationBuilder put(DataVariable<T> variable, T value) {
+                return putChecked(variable, value);
+        }
+
+        public ValuationBuilder putChecked(AnyDataVariable variable, Object value) {
+                if (value != null && !variable.getType().isInstance(value)) {
+                        throw new IllegalArgumentException("Value %s is not an instance of %s"
+                                        .formatted(value, variable.getType().getName()));
+                }
+                if (values.containsKey(variable)) {
+                        throw new IllegalArgumentException("Already has value for variable %s".formatted(variable));
+                }
+                values.put(variable, value);
+                return this;
+        }
+
+        public Valuation build() {
+                return new MapBasedValuation(Collections.unmodifiableMap(values));
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/AbstractFunctionView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/AbstractFunctionView.java
new file mode 100644
index 00000000..fd37604e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/AbstractFunctionView.java
@@ -0,0 +1,110 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.view;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.dnf.FunctionalDependency;
+import tools.refinery.store.query.term.Parameter;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple1;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public abstract class AbstractFunctionView<T> extends SymbolView<T> {
+        private final List<Parameter> parameters;
+
+        protected AbstractFunctionView(Symbol<T> symbol, String name, Parameter outParameter) {
+                super(symbol, name);
+                parameters = createParameters(symbol.arity(), outParameter);
+        }
+
+        @Override
+        public Set<FunctionalDependency<Integer>> getFunctionalDependencies() {
+                var arity = getSymbol().arity();
+                var forEach = IntStream.range(0, arity).boxed().collect(Collectors.toUnmodifiableSet());
+                var unique = Set.of(arity);
+                return Set.of(new FunctionalDependency<>(forEach, unique));
+        }
+
+        @Override
+        public Set<ViewImplication> getImpliedRelationViews() {
+                var symbol = getSymbol();
+                var impliedIndices = IntStream.range(0, symbol.arity()).boxed().toList();
+                var keysView = new KeyOnlyView<>(symbol);
+                return Set.of(new ViewImplication(this, keysView, impliedIndices));
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, T value) {
+                return true;
+        }
+
+        protected Object forwardMapValue(T value) {
+                return value;
+        }
+
+        protected boolean valueEquals(T value, Object otherForwardMappedValue) {
+                return Objects.equals(otherForwardMappedValue, forwardMapValue(value));
+        }
+
+        @Override
+        public Object[] forwardMap(Tuple key, T value) {
+                int size = key.getSize();
+                Object[] result = new Object[size + 1];
+                for (int i = 0; i < size; i++) {
+                        result[i] = Tuple.of(key.get(i));
+                }
+                result[key.getSize()] = forwardMapValue(value);
+                return result;
+        }
+
+        @Override
+        public boolean get(Model model, Object[] tuple) {
+                int[] content = new int[tuple.length - 1];
+                for (int i = 0; i < tuple.length - 1; i++) {
+                        if (!(tuple[i] instanceof Tuple1 wrapper)) {
+                                return false;
+                        }
+                        content[i] = wrapper.value0();
+                }
+                Tuple key = Tuple.of(content);
+                var valueInTuple = tuple[tuple.length - 1];
+                T valueInMap = model.getInterpretation(getSymbol()).get(key);
+                return valueEquals(valueInMap, valueInTuple);
+        }
+
+        @Override
+        public List<Parameter> getParameters() {
+                return parameters;
+        }
+
+        @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;
+                AbstractFunctionView<?> that = (AbstractFunctionView<?>) o;
+                return Objects.equals(parameters, that.parameters);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), parameters);
+        }
+
+        private static List<Parameter> createParameters(int symbolArity, Parameter outParameter) {
+                var parameters = new Parameter[symbolArity + 1];
+                Arrays.fill(parameters, Parameter.NODE_OUT);
+                parameters[symbolArity] = outParameter;
+                return List.of(parameters);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/AnySymbolView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/AnySymbolView.java
new file mode 100644
index 00000000..90b27ebb
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/AnySymbolView.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.view;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.dnf.FunctionalDependency;
+import tools.refinery.store.representation.AnySymbol;
+import tools.refinery.store.query.Constraint;
+
+import java.util.Set;
+
+public sealed interface AnySymbolView extends Constraint permits SymbolView {
+        AnySymbol getSymbol();
+
+        String getViewName();
+
+        default Set<FunctionalDependency<Integer>> getFunctionalDependencies() {
+                return Set.of();
+        }
+
+        default Set<ViewImplication> getImpliedRelationViews() {
+                return Set.of();
+        }
+
+        boolean get(Model model, Object[] tuple);
+
+        Iterable<Object[]> getAll(Model model);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java
new file mode 100644
index 00000000..abae6e5c
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredView.java
@@ -0,0 +1,73 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.view;
+
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.representation.Symbol;
+
+import java.util.Objects;
+import java.util.function.BiPredicate;
+import java.util.function.Predicate;
+
+public class FilteredView<T> extends TuplePreservingView<T> {
+        private final BiPredicate<Tuple, T> predicate;
+
+        public FilteredView(Symbol<T> symbol, String name, BiPredicate<Tuple, T> predicate) {
+                super(symbol, name);
+                this.predicate = predicate;
+        }
+
+        public FilteredView(Symbol<T> symbol, BiPredicate<Tuple, T> predicate) {
+                super(symbol);
+                this.predicate = predicate;
+        }
+
+        public FilteredView(Symbol<T> symbol, String name, Predicate<T> predicate) {
+                this(symbol, name, (k, v) -> predicate.test(v));
+                validateDefaultValue(predicate);
+        }
+
+        public FilteredView(Symbol<T> symbol, Predicate<T> predicate) {
+                this(symbol, (k, v) -> predicate.test(v));
+                validateDefaultValue(predicate);
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, T value) {
+                return this.predicate.test(key, value);
+        }
+
+        @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;
+                FilteredView<?> that = (FilteredView<?>) o;
+                return Objects.equals(predicate, that.predicate);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), predicate);
+        }
+
+        private void validateDefaultValue(Predicate<T> predicate) {
+                var defaultValue = getSymbol().defaultValue();
+                boolean matchesDefaultValue = false;
+                try {
+                        matchesDefaultValue = predicate.test(defaultValue);
+                } catch (NullPointerException e) {
+                        if (defaultValue != null) {
+                                throw e;
+                        }
+                        // The predicate doesn't need to handle the default value if it is null.
+                }
+                if (matchesDefaultValue) {
+                        throw new IllegalArgumentException("Tuples with default value %s cannot be enumerated in %s"
+                                        .formatted(defaultValue, getSymbol()));
+                }
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/ForbiddenView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/ForbiddenView.java
new file mode 100644
index 00000000..c312330e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/ForbiddenView.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.view;
+
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+public class ForbiddenView extends TuplePreservingView<TruthValue> {
+        public ForbiddenView(Symbol<TruthValue> symbol) {
+                super(symbol, "forbidden");
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, TruthValue value) {
+                return !value.may();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FunctionView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FunctionView.java
new file mode 100644
index 00000000..74a5be07
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FunctionView.java
@@ -0,0 +1,36 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.view;
+
+import tools.refinery.store.query.term.*;
+import tools.refinery.store.representation.Symbol;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class FunctionView<T> extends AbstractFunctionView<T> {
+        public FunctionView(Symbol<T> symbol, String name) {
+                super(symbol, name, new Parameter(symbol.valueType(), ParameterDirection.OUT));
+        }
+
+        public FunctionView(Symbol<T> symbol) {
+                this(symbol, "function");
+        }
+
+        public <R> AssignedValue<R> aggregate(Aggregator<R, T> aggregator, List<NodeVariable> arguments) {
+                return targetVariable -> {
+                        var placeholderVariable = Variable.of(getSymbol().valueType());
+                        var argumentsWithPlaceholder = new ArrayList<Variable>(arguments.size() + 1);
+                        argumentsWithPlaceholder.addAll(arguments);
+                        argumentsWithPlaceholder.add(placeholderVariable);
+                        return aggregateBy(placeholderVariable, aggregator, argumentsWithPlaceholder).toLiteral(targetVariable);
+                };
+        }
+
+        public <R> AssignedValue<R> aggregate(Aggregator<R, T> aggregator, NodeVariable... arguments) {
+                return aggregate(aggregator, List.of(arguments));
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/KeyOnlyView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/KeyOnlyView.java
new file mode 100644
index 00000000..f0e4a61e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/KeyOnlyView.java
@@ -0,0 +1,41 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.view;
+
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Objects;
+
+public final class KeyOnlyView<T> extends TuplePreservingView<T> {
+        public static final String VIEW_NAME = "key";
+
+        private final T defaultValue;
+
+        public KeyOnlyView(Symbol<T> symbol) {
+                super(symbol, VIEW_NAME);
+                defaultValue = symbol.defaultValue();
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, T value) {
+                return true;
+        }
+
+        @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;
+                KeyOnlyView<?> that = (KeyOnlyView<?>) o;
+                return Objects.equals(defaultValue, that.defaultValue);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), defaultValue);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MayView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MayView.java
new file mode 100644
index 00000000..c322e220
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MayView.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.view;
+
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+public class MayView extends TuplePreservingView<TruthValue> {
+        public MayView(Symbol<TruthValue> symbol) {
+                super(symbol, "may");
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, TruthValue value) {
+                return value.may();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MustView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MustView.java
new file mode 100644
index 00000000..65bb4e4c
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MustView.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.view;
+
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+public class MustView extends TuplePreservingView<TruthValue> {
+        public MustView(Symbol<TruthValue> symbol) {
+                super(symbol, "must");
+        }
+
+        @Override
+        protected boolean doFilter(Tuple key, TruthValue value) {
+                return value.must();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/NodeFunctionView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/NodeFunctionView.java
new file mode 100644
index 00000000..fcf11506
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/NodeFunctionView.java
@@ -0,0 +1,20 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.view;
+
+import tools.refinery.store.query.term.Parameter;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple1;
+
+public final class NodeFunctionView extends AbstractFunctionView<Tuple1> {
+        public NodeFunctionView(Symbol<Tuple1> symbol, String name) {
+                super(symbol, name, Parameter.NODE_OUT);
+        }
+
+        public NodeFunctionView(Symbol<Tuple1> symbol) {
+                this(symbol, "function");
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/SymbolView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/SymbolView.java
new file mode 100644
index 00000000..cd8bd56b
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/SymbolView.java
@@ -0,0 +1,85 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.view;
+
+import tools.refinery.store.map.CursorAsIterator;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Objects;
+import java.util.UUID;
+
+/**
+ * Represents a view of a {@link Symbol} that can be queried.
+ *
+ * @param <T>
+ * @author Oszkar Semerath
+ */
+public abstract non-sealed class SymbolView<T> implements AnySymbolView {
+        private final Symbol<T> symbol;
+        private final String viewName;
+
+        protected SymbolView(Symbol<T> symbol, String viewName) {
+                this.symbol = symbol;
+                this.viewName = viewName;
+        }
+
+        protected SymbolView(Symbol<T> representation) {
+                this(representation, UUID.randomUUID().toString());
+        }
+
+        @Override
+        public Symbol<T> getSymbol() {
+                return symbol;
+        }
+
+        @Override
+        public String getViewName() {
+                return viewName;
+        }
+
+        @Override
+        public String name() {
+                return symbol.name() + "#" + viewName;
+        }
+
+        public final boolean filter(Tuple key, T value) {
+                return !Objects.equals(symbol.defaultValue(), value) && doFilter(key, value);
+        }
+
+        protected abstract boolean doFilter(Tuple key, T value);
+
+        public abstract Object[] forwardMap(Tuple key, T value);
+
+        @Override
+        public Iterable<Object[]> getAll(Model model) {
+                return (() -> new CursorAsIterator<>(model.getInterpretation(symbol).getAll(), this::forwardMap, this::filter));
+        }
+
+        @Override
+        public String toString() {
+                return name();
+        }
+
+        @Override
+        public String toReferenceString() {
+                return "@RelationView(\"%s\") %s".formatted(viewName, symbol.name());
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                SymbolView<?> that = (SymbolView<?>) o;
+                return Objects.equals(symbol, that.symbol) && Objects.equals(viewName, that.viewName);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(getClass(), symbol, viewName);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/TuplePreservingView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/TuplePreservingView.java
new file mode 100644
index 00000000..6bc5a708
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/TuplePreservingView.java
@@ -0,0 +1,82 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.view;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.Parameter;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.Tuple1;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+public abstract class TuplePreservingView<T> extends SymbolView<T> {
+        private final List<Parameter> parameters;
+
+        protected TuplePreservingView(Symbol<T> symbol, String name) {
+                super(symbol, name);
+                this.parameters = createParameters(symbol.arity());
+        }
+
+        protected TuplePreservingView(Symbol<T> symbol) {
+                super(symbol);
+                this.parameters = createParameters(symbol.arity());
+        }
+
+        public Object[] forwardMap(Tuple key) {
+                Object[] result = new Object[key.getSize()];
+                for (int i = 0; i < key.getSize(); i++) {
+                        result[i] = Tuple.of(key.get(i));
+                }
+                return result;
+        }
+
+        @Override
+        public Object[] forwardMap(Tuple key, T value) {
+                return forwardMap(key);
+        }
+
+        @Override
+        public boolean get(Model model, Object[] tuple) {
+                int[] content = new int[tuple.length];
+                for (int i = 0; i < tuple.length; i++) {
+                        if (!(tuple[i] instanceof Tuple1 wrapper)) {
+                                return false;
+                        }
+                        content[i] = wrapper.value0();
+                }
+                Tuple key = Tuple.of(content);
+                T value = model.getInterpretation(getSymbol()).get(key);
+                return filter(key, value);
+        }
+
+        @Override
+        public List<Parameter> getParameters() {
+                return parameters;
+        }
+
+        @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;
+                TuplePreservingView<?> that = (TuplePreservingView<?>) o;
+                return Objects.equals(parameters, that.parameters);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), parameters);
+        }
+
+        private static List<Parameter> createParameters(int arity) {
+                var parameters = new Parameter[arity];
+                Arrays.fill(parameters, Parameter.NODE_OUT);
+                return List.of(parameters);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/ViewImplication.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/ViewImplication.java
new file mode 100644
index 00000000..fc2db9f2
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/ViewImplication.java
@@ -0,0 +1,23 @@
+/*
+ * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.view;
+
+import java.util.List;
+
+public record ViewImplication(AnySymbolView implyingView, AnySymbolView impliedView, List<Integer> impliedIndices) {
+        public ViewImplication {
+                if (impliedIndices.size() != impliedView.arity()) {
+                        throw new IllegalArgumentException("Expected %d implied indices for %s, but %d are provided"
+                                        .formatted(impliedView.arity(), impliedView, impliedIndices.size()));
+                }
+                for (var index : impliedIndices) {
+                        if (impliedView.invalidIndex(index)) {
+                                throw new IllegalArgumentException("%d is not a valid index for %s".formatted(index,
+                                                implyingView));
+                        }
+                }
+        }
+}