Merge pull request #24 from kris7t/partial-interpretation

Changes for supporting partial interpretation

239 files changed, 10460 insertions, 1260 deletions

diff --git a/subprojects/frontend/package.json b/subprojects/frontend/package.json
index a9153cd4..a761e74c 100644
--- a/subprojects/frontend/package.json
+++ b/subprojects/frontend/package.json
@@ -2,6 +2,7 @@
   "name": "@refinery/frontend",
   "version": "0.0.0",
   "description": "Web frontend for Refinery",
+  "type": "module",
   "private": true,
   "scripts": {
     "build": "cross-env MODE=production vite build",
@@ -23,60 +24,61 @@
   },
   "homepage": "https://refinery.tools",
   "dependencies": {
-    "@codemirror/autocomplete": "^6.4.0",
-    "@codemirror/commands": "^6.2.0",
-    "@codemirror/language": "^6.4.0",
-    "@codemirror/lint": "^6.1.0",
-    "@codemirror/search": "^6.2.3",
+    "@codemirror/autocomplete": "^6.4.2",
+    "@codemirror/commands": "^6.2.2",
+    "@codemirror/language": "^6.6.0",
+    "@codemirror/lint": "^6.2.0",
+    "@codemirror/search": "^6.3.0",
     "@codemirror/state": "^6.2.0",
-    "@codemirror/view": "^6.7.3",
-    "@emotion/react": "^11.10.5",
-    "@emotion/styled": "^11.10.5",
+    "@codemirror/view": "^6.9.3",
+    "@emotion/react": "^11.10.6",
+    "@emotion/styled": "^11.10.6",
     "@fontsource/inter": "^4.5.15",
     "@fontsource/jetbrains-mono": "^4.5.12",
     "@lezer/common": "^1.0.2",
-    "@lezer/highlight": "^1.1.3",
+    "@lezer/highlight": "^1.1.4",
     "@lezer/lr": "^1.3.3",
     "@material-icons/svg": "^1.0.33",
-    "@mui/icons-material": "5.11.0",
-    "@mui/material": "5.11.7",
-    "@vitejs/plugin-react-swc": "^3.1.0",
+    "@mui/icons-material": "5.11.11",
+    "@mui/material": "5.11.15",
+    "@vitejs/plugin-react-swc": "^3.2.0",
     "ansi-styles": "^6.2.1",
+    "csstype": "^3.1.1",
     "escape-string-regexp": "^5.0.0",
     "lodash-es": "^4.17.21",
     "loglevel": "^1.8.1",
     "loglevel-plugin-prefix": "^0.8.4",
-    "mobx": "^6.7.0",
-    "mobx-react-lite": "^3.4.0",
+    "mobx": "^6.9.0",
+    "mobx-react-lite": "^3.4.3",
     "ms": "^2.1.3",
-    "nanoid": "^4.0.0",
-    "notistack": "^2.0.8",
+    "nanoid": "^4.0.2",
+    "notistack": "^3.0.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "xstate": "^4.35.4",
-    "zod": "^3.20.2"
+    "xstate": "^4.37.1",
+    "zod": "^3.21.4"
   },
   "devDependencies": {
     "@lezer/generator": "^1.2.2",
-    "@tsconfig/node18-strictest-esm": "^1.0.1",
-    "@types/eslint": "^8.21.0",
+    "@tsconfig/strictest": "^2.0.0",
+    "@types/eslint": "^8.37.0",
     "@types/html-minifier-terser": "^7.0.0",
-    "@types/lodash-es": "^4.17.6",
+    "@types/lodash-es": "^4.17.7",
     "@types/micromatch": "^4.0.2",
     "@types/ms": "^0.7.31",
-    "@types/node": "^18.11.18",
+    "@types/node": "^18.15.11",
     "@types/prettier": "^2.7.2",
-    "@types/react": "^18.0.27",
-    "@types/react-dom": "^18.0.10",
-    "@typescript-eslint/eslint-plugin": "^5.50.0",
-    "@typescript-eslint/parser": "^5.50.0",
+    "@types/react": "^18.0.31",
+    "@types/react-dom": "^18.0.11",
+    "@typescript-eslint/eslint-plugin": "^5.57.0",
+    "@typescript-eslint/parser": "^5.57.0",
     "@xstate/cli": "^0.4.2",
     "cross-env": "^7.0.3",
-    "eslint": "^8.33.0",
+    "eslint": "^8.37.0",
     "eslint-config-airbnb": "^19.0.4",
     "eslint-config-airbnb-typescript": "^17.0.0",
-    "eslint-config-prettier": "^8.6.0",
-    "eslint-import-resolver-typescript": "^3.5.3",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-import-resolver-typescript": "^3.5.4",
     "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-jsx-a11y": "^6.7.1",
     "eslint-plugin-mobx": "^0.0.9",
@@ -85,10 +87,10 @@
     "eslint-plugin-react-hooks": "^4.6.0",
     "html-minifier-terser": "^7.1.0",
     "micromatch": "^4.0.5",
-    "prettier": "^2.8.3",
-    "typescript": "4.9.5",
-    "vite": "^4.1.1",
-    "vite-plugin-pwa": "^0.14.1",
+    "prettier": "^2.8.7",
+    "typescript": "5.0.3",
+    "vite": "^4.2.1",
+    "vite-plugin-pwa": "^0.14.7",
     "workbox-window": "^6.5.4"
   }
 }
diff --git a/subprojects/frontend/src/Refinery.tsx b/subprojects/frontend/src/Refinery.tsx
index 93a82ee1..f0162349 100644
--- a/subprojects/frontend/src/Refinery.tsx
+++ b/subprojects/frontend/src/Refinery.tsx
@@ -8,7 +8,6 @@ import EditorPane from './editor/EditorPane';
 
 export default function Refinery(): JSX.Element {
   return (
-    // @ts-expect-error -- notistack has problems with `exactOptionalPropertyTypes
     <SnackbarProvider TransitionComponent={Grow}>
       <UpdateNotification />
       <Stack direction="column" height="100%" overflow="auto">
diff --git a/subprojects/frontend/src/UpdateNotification.tsx b/subprojects/frontend/src/UpdateNotification.tsx
index 07f7f5f7..5c8c2d01 100644
--- a/subprojects/frontend/src/UpdateNotification.tsx
+++ b/subprojects/frontend/src/UpdateNotification.tsx
@@ -32,14 +32,14 @@ export default observer(function UpdateNotification(): null {
       return enqueueLater('Failed to download update', {
         variant: 'error',
         action: (
-          <>
+          <ContrastThemeProvider>
             <Button color="inherit" onClick={() => pwaStore.checkForUpdates()}>
               Try again
             </Button>
             <Button color="inherit" onClick={() => pwaStore.dismissError()}>
               Dismiss
             </Button>
-          </>
+          </ContrastThemeProvider>
         ),
       });
     }
diff --git a/subprojects/frontend/src/editor/scrollbarViewPlugin.ts b/subprojects/frontend/src/editor/scrollbarViewPlugin.ts
index f54251a9..f44034fd 100644
--- a/subprojects/frontend/src/editor/scrollbarViewPlugin.ts
+++ b/subprojects/frontend/src/editor/scrollbarViewPlugin.ts
@@ -266,7 +266,6 @@ export default function scrollbarViewPlugin(
         if (firstRunTimeout !== undefined) {
           clearTimeout(firstRunTimeout);
         }
-        // @ts-expect-error `@types/node` typings should not be in effect here.
         firstRunTimeout = setTimeout(() => {
           spacer.style.minHeight = `${scrollHeight}px`;
           firstRun = false;
diff --git a/subprojects/frontend/src/theme/ThemeProvider.tsx b/subprojects/frontend/src/theme/ThemeProvider.tsx
index 7bda1ede..ff97d524 100644
--- a/subprojects/frontend/src/theme/ThemeProvider.tsx
+++ b/subprojects/frontend/src/theme/ThemeProvider.tsx
@@ -6,7 +6,6 @@ import {
   type ThemeOptions,
   ThemeProvider as MaterialUiThemeProvider,
   type TypographyStyle,
-  useTheme,
   type CSSObject,
 } from '@mui/material/styles';
 import { observer } from 'mobx-react-lite';
@@ -350,15 +349,14 @@ export function ContrastThemeProvider({
 }: {
   children?: ReactNode;
 }): JSX.Element {
-  const theme = useTheme();
   const contrastTheme = useContext(ContrastThemeContext);
   if (!contrastTheme) {
     throw new Error('ContrastThemeProvider must be used within ThemeProvider');
   }
   return (
-    <ThemeAndContrastThemeProvider theme={contrastTheme} contrastTheme={theme}>
+    <MaterialUiThemeProvider theme={contrastTheme}>
       {children}
-    </ThemeAndContrastThemeProvider>
+    </MaterialUiThemeProvider>
   );
 }
 
@@ -378,7 +376,7 @@ const ThemeProvider = observer(function ThemeProvider({
   return (
     <ThemeAndContrastThemeProvider
       theme={darkMode ? darkTheme : lightTheme}
-      contrastTheme={darkMode ? lightTheme : darkTheme}
+      contrastTheme={darkTheme}
     >
       {children}
     </ThemeAndContrastThemeProvider>
diff --git a/subprojects/frontend/src/utils/PendingTask.ts b/subprojects/frontend/src/utils/PendingTask.ts
index fd52cef1..d0b24c1f 100644
--- a/subprojects/frontend/src/utils/PendingTask.ts
+++ b/subprojects/frontend/src/utils/PendingTask.ts
@@ -20,7 +20,6 @@ export default class PendingTask<T> {
   ) {
     this.resolveCallback = resolveCallback;
     this.rejectCallback = rejectCallback;
-    // @ts-expect-error See https://github.com/mobxjs/mobx/issues/3582 on `@types/node` pollution
     this.timeout = setTimeout(() => {
       if (!this.resolved) {
         this.reject(new TimeoutError());
diff --git a/subprojects/frontend/src/utils/useDelayedSnackbar.ts b/subprojects/frontend/src/utils/useDelayedSnackbar.ts
index 54716c0c..03ad6caa 100644
--- a/subprojects/frontend/src/utils/useDelayedSnackbar.ts
+++ b/subprojects/frontend/src/utils/useDelayedSnackbar.ts
@@ -21,7 +21,6 @@ export default function useDelayedSnackbar(
       delay = defaultDelay,
     ) => {
       let key: SnackbarKey | undefined;
-      // @ts-expect-error See https://github.com/mobxjs/mobx/issues/3582 on `@types/node` pollution
       let timeout: number | undefined = setTimeout(() => {
         timeout = undefined;
         key = enqueueSnackbar(message, options);
diff --git a/subprojects/frontend/src/xtext/webSocketMachine.ts b/subprojects/frontend/src/xtext/webSocketMachine.ts
index 216ed86a..fc53fef3 100644
--- a/subprojects/frontend/src/xtext/webSocketMachine.ts
+++ b/subprojects/frontend/src/xtext/webSocketMachine.ts
@@ -1,5 +1,5 @@
 import ms from 'ms';
-import { actions, assign, createMachine, RaiseAction } from 'xstate';
+import { actions, assign, createMachine } from 'xstate';
 
 const { raise } = actions;
 
@@ -217,16 +217,15 @@ export default createMachine(
         ...context,
         errors: [],
       })),
-      // Workaround from https://github.com/statelyai/xstate/issues/1414#issuecomment-699972485
       raiseTimeoutError: raise({
         type: 'ERROR',
         message: 'Open timeout',
-      }) as RaiseAction<WebSocketEvent>,
+      }),
       raisePromiseRejectionError: (_context, { data }) =>
-        raise({
+        raise<WebSocketContext, WebSocketEvent>({
           type: 'ERROR',
-          message: data,
-        }) as RaiseAction<WebSocketEvent>,
+          message: String(data),
+        }),
     },
   },
 );
diff --git a/subprojects/frontend/tsconfig.base.json b/subprojects/frontend/tsconfig.base.json
index 585866f1..b960e93c 100644
--- a/subprojects/frontend/tsconfig.base.json
+++ b/subprojects/frontend/tsconfig.base.json
@@ -1,7 +1,10 @@
 {
-  "extends": "@tsconfig/node18-strictest-esm/tsconfig.json",
+  "extends": "@tsconfig/strictest",
   "compilerOptions": {
     "useDefineForClassFields": true,
+    "verbatimModuleSyntax": false,
     "isolatedModules": true,
+    "module": "es2022",
+    "moduleResolution": "node"
   }
 }
diff --git a/subprojects/language-model/META-INF/MANIFEST.MF b/subprojects/language-model/META-INF/MANIFEST.MF
index a9c6340a..5d36a475 100644
--- a/subprojects/language-model/META-INF/MANIFEST.MF
+++ b/subprojects/language-model/META-INF/MANIFEST.MF
@@ -7,7 +7,7 @@ Bundle-Version: 0.0.0.qualifier
 Bundle-ClassPath: .
 Bundle-Vendor: %providerName
 Bundle-Localization: plugin
-Bundle-RequiredExecutionEnvironment: JavaSE-17
+Bundle-RequiredExecutionEnvironment: J2SE-1.5
 Export-Package: tools.refinery.language.model,
  tools.refinery.language.model.problem,
  tools.refinery.language.model.problem.impl,
diff --git a/subprojects/store-query-viatra/build.gradle b/subprojects/store-query-viatra/build.gradle
index c12b48fe..13a7544f 100644
--- a/subprojects/store-query-viatra/build.gradle
+++ b/subprojects/store-query-viatra/build.gradle
@@ -10,7 +10,7 @@ configurations.testRuntimeClasspath {
 dependencies {
         implementation libs.ecore
         api libs.viatra
-        api project(':refinery-store')
+        api project(':refinery-store-query')
         testImplementation libs.slf4j.simple
         testImplementation libs.slf4j.log4j
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraModelQueryBuilder.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraModelQueryBuilder.java
index efc6146c..7ae86f9f 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraModelQueryBuilder.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraModelQueryBuilder.java
@@ -4,7 +4,8 @@ import org.eclipse.viatra.query.runtime.api.ViatraQueryEngineOptions;
 import org.eclipse.viatra.query.runtime.matchers.backend.IQueryBackendFactory;
 import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
 import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.query.DNF;
+import tools.refinery.store.query.dnf.AnyQuery;
+import tools.refinery.store.query.dnf.Dnf;
 import tools.refinery.store.query.ModelQueryBuilder;
 
 import java.util.Collection;
@@ -23,25 +24,25 @@ public interface ViatraModelQueryBuilder extends ModelQueryBuilder {
         ViatraModelQueryBuilder searchBackend(IQueryBackendFactory queryBackendFactory);
 
         @Override
-        default ViatraModelQueryBuilder queries(DNF... queries) {
+        default ViatraModelQueryBuilder queries(AnyQuery... queries) {
                 ModelQueryBuilder.super.queries(queries);
                 return this;
         }
 
         @Override
-        default ViatraModelQueryBuilder queries(Collection<DNF> queries) {
+        default ViatraModelQueryBuilder queries(Collection<? extends AnyQuery> queries) {
                 ModelQueryBuilder.super.queries(queries);
                 return this;
         }
 
         @Override
-        ViatraModelQueryBuilder query(DNF query);
+        ViatraModelQueryBuilder query(AnyQuery query);
 
-        ViatraModelQueryBuilder query(DNF query, QueryEvaluationHint queryEvaluationHint);
+        ViatraModelQueryBuilder query(AnyQuery query, QueryEvaluationHint queryEvaluationHint);
 
-        ViatraModelQueryBuilder computeHint(Function<DNF, QueryEvaluationHint> computeHint);
+        ViatraModelQueryBuilder computeHint(Function<Dnf, QueryEvaluationHint> computeHint);
 
-        ViatraModelQueryBuilder hint(DNF dnf, QueryEvaluationHint queryEvaluationHint);
+        ViatraModelQueryBuilder hint(Dnf dnf, QueryEvaluationHint queryEvaluationHint);
 
         @Override
         ViatraModelQueryStoreAdapter createStoreAdapter(ModelStore store);
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryAdapterImpl.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryAdapterImpl.java
index 039f46fa..8be30fee 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryAdapterImpl.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryAdapterImpl.java
@@ -7,62 +7,92 @@ import org.eclipse.viatra.query.runtime.internal.apiimpl.ViatraQueryEngineImpl;
 import org.eclipse.viatra.query.runtime.matchers.backend.IQueryBackend;
 import org.eclipse.viatra.query.runtime.matchers.backend.IQueryBackendFactory;
 import tools.refinery.store.model.Model;
-import tools.refinery.store.query.DNF;
+import tools.refinery.store.model.ModelListener;
+import tools.refinery.store.query.AnyResultSet;
+import tools.refinery.store.query.EmptyResultSet;
 import tools.refinery.store.query.ResultSet;
+import tools.refinery.store.query.dnf.AnyQuery;
+import tools.refinery.store.query.dnf.FunctionalQuery;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.dnf.RelationalQuery;
 import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
+import tools.refinery.store.query.viatra.internal.matcher.FunctionalViatraMatcher;
+import tools.refinery.store.query.viatra.internal.matcher.RawPatternMatcher;
+import tools.refinery.store.query.viatra.internal.matcher.RelationalViatraMatcher;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.Map;
 
-public class ViatraModelQueryAdapterImpl implements ViatraModelQueryAdapter {
+public class ViatraModelQueryAdapterImpl implements ViatraModelQueryAdapter, ModelListener {
         private static final String DELAY_MESSAGE_DELIVERY_FIELD_NAME = "delayMessageDelivery";
+        private static final MethodHandle SET_UPDATE_PROPAGATION_DELAYED_HANDLE;
         private static final String QUERY_BACKENDS_FIELD_NAME = "queryBackends";
+        private static final MethodHandle GET_QUERY_BACKENDS_HANDLE;
 
         private final Model model;
         private final ViatraModelQueryStoreAdapterImpl storeAdapter;
         private final ViatraQueryEngineImpl queryEngine;
-        private final MethodHandle setUpdatePropagationDelayedHandle;
-        private final MethodHandle getQueryBackendsHandle;
-        private final Map<DNF, ResultSet> resultSets;
+        private final Map<AnyQuery, AnyResultSet> resultSets;
         private boolean pendingChanges;
 
-        ViatraModelQueryAdapterImpl(Model model, ViatraModelQueryStoreAdapterImpl storeAdapter) {
-                this.model = model;
-                this.storeAdapter = storeAdapter;
-                var scope = new RelationalScope(this);
-                queryEngine = (ViatraQueryEngineImpl) AdvancedViatraQueryEngine.createUnmanagedEngine(scope);
-
+        static {
                 try {
                         var lookup = MethodHandles.privateLookupIn(ViatraQueryEngineImpl.class, MethodHandles.lookup());
-                        setUpdatePropagationDelayedHandle = lookup.findSetter(ViatraQueryEngineImpl.class,
+                        SET_UPDATE_PROPAGATION_DELAYED_HANDLE = lookup.findSetter(ViatraQueryEngineImpl.class,
                                         DELAY_MESSAGE_DELIVERY_FIELD_NAME, Boolean.TYPE);
-                        getQueryBackendsHandle = lookup.findGetter(ViatraQueryEngineImpl.class, QUERY_BACKENDS_FIELD_NAME,
+                        GET_QUERY_BACKENDS_HANDLE = lookup.findGetter(ViatraQueryEngineImpl.class, QUERY_BACKENDS_FIELD_NAME,
                                         Map.class);
                 } catch (IllegalAccessException | NoSuchFieldException e) {
                         throw new IllegalStateException("Cannot access private members of %s"
                                         .formatted(ViatraQueryEngineImpl.class.getName()), e);
                 }
+        }
+
+        ViatraModelQueryAdapterImpl(Model model, ViatraModelQueryStoreAdapterImpl storeAdapter) {
+                this.model = model;
+                this.storeAdapter = storeAdapter;
+                var scope = new RelationalScope(this);
+                queryEngine = (ViatraQueryEngineImpl) AdvancedViatraQueryEngine.createUnmanagedEngine(scope,
+                                storeAdapter.getEngineOptions());
 
                 var querySpecifications = storeAdapter.getQuerySpecifications();
                 GenericQueryGroup.of(
                                 Collections.<IQuerySpecification<?>>unmodifiableCollection(querySpecifications.values()).stream()
                 ).prepare(queryEngine);
-                resultSets = new HashMap<>(querySpecifications.size());
+                var vacuousQueries = storeAdapter.getVacuousQueries();
+                resultSets = new LinkedHashMap<>(querySpecifications.size() + vacuousQueries.size());
                 for (var entry : querySpecifications.entrySet()) {
-                        var matcher = queryEngine.getMatcher(entry.getValue());
-                        resultSets.put(entry.getKey(), matcher);
+                        var rawPatternMatcher = queryEngine.getMatcher(entry.getValue());
+                        var query = entry.getKey();
+                        resultSets.put(query, createResultSet((Query<?>) query, rawPatternMatcher));
+                }
+                for (var vacuousQuery : vacuousQueries) {
+                        resultSets.put(vacuousQuery, new EmptyResultSet<>(this, (Query<?>) vacuousQuery));
                 }
 
                 setUpdatePropagationDelayed(true);
+                model.addListener(this);
+        }
+
+        private <T> ResultSet<T> createResultSet(Query<T> query, RawPatternMatcher matcher) {
+                if (query instanceof RelationalQuery relationalQuery) {
+                        @SuppressWarnings("unchecked")
+                        var resultSet = (ResultSet<T>) new RelationalViatraMatcher(this, relationalQuery, matcher);
+                        return resultSet;
+                } else if (query instanceof FunctionalQuery<T> functionalQuery) {
+                        return new FunctionalViatraMatcher<>(this, functionalQuery, matcher);
+                } else {
+                        throw new IllegalArgumentException("Unknown query: " + query);
+                }
         }
 
         private void setUpdatePropagationDelayed(boolean value) {
                 try {
-                        setUpdatePropagationDelayedHandle.invokeExact(queryEngine, value);
+                        SET_UPDATE_PROPAGATION_DELAYED_HANDLE.invokeExact(queryEngine, value);
                 } catch (Error e) {
                         // Fatal JVM errors should not be wrapped.
                         throw e;
@@ -74,7 +104,7 @@ public class ViatraModelQueryAdapterImpl implements ViatraModelQueryAdapter {
         private Collection<IQueryBackend> getQueryBackends() {
                 try {
                         @SuppressWarnings("unchecked")
-                        var backendMap = (Map<IQueryBackendFactory, IQueryBackend>) getQueryBackendsHandle.invokeExact(queryEngine);
+                        var backendMap = (Map<IQueryBackendFactory, IQueryBackend>) GET_QUERY_BACKENDS_HANDLE.invokeExact(queryEngine);
                         return backendMap.values();
                 } catch (Error e) {
                         // Fatal JVM errors should not be wrapped.
@@ -95,12 +125,14 @@ public class ViatraModelQueryAdapterImpl implements ViatraModelQueryAdapter {
         }
 
         @Override
-        public ResultSet getResultSet(DNF query) {
+        public <T> ResultSet<T> getResultSet(Query<T> query) {
                 var resultSet = resultSets.get(query);
                 if (resultSet == null) {
                         throw new IllegalArgumentException("No matcher for query %s in model".formatted(query.name()));
                 }
-                return resultSet;
+                @SuppressWarnings("unchecked")
+                var typedResultSet = (ResultSet<T>) resultSet;
+                return typedResultSet;
         }
 
         @Override
@@ -132,4 +164,9 @@ public class ViatraModelQueryAdapterImpl implements ViatraModelQueryAdapter {
                 }
                 pendingChanges = false;
         }
+
+        @Override
+        public void afterRestore() {
+                flushChanges();
+        }
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryBuilderImpl.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryBuilderImpl.java
index 9f1e55b1..bfabf26e 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryBuilderImpl.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryBuilderImpl.java
@@ -2,34 +2,40 @@ package tools.refinery.store.query.viatra.internal;
 
 import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
 import org.eclipse.viatra.query.runtime.api.ViatraQueryEngineOptions;
-import org.eclipse.viatra.query.runtime.localsearch.matcher.integration.LocalSearchGenericBackendFactory;
+import org.eclipse.viatra.query.runtime.localsearch.matcher.integration.LocalSearchHintOptions;
 import org.eclipse.viatra.query.runtime.matchers.backend.IQueryBackendFactory;
 import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
 import org.eclipse.viatra.query.runtime.rete.matcher.ReteBackendFactory;
 import tools.refinery.store.adapter.AbstractModelAdapterBuilder;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreBuilder;
-import tools.refinery.store.query.DNF;
+import tools.refinery.store.query.dnf.AnyQuery;
+import tools.refinery.store.query.dnf.Dnf;
 import tools.refinery.store.query.viatra.ViatraModelQueryBuilder;
-import tools.refinery.store.query.viatra.internal.pquery.DNF2PQuery;
-import tools.refinery.store.query.viatra.internal.pquery.RawPatternMatcher;
+import tools.refinery.store.query.viatra.internal.localsearch.FlatCostFunction;
+import tools.refinery.store.query.viatra.internal.localsearch.RelationalLocalSearchBackendFactory;
+import tools.refinery.store.query.viatra.internal.matcher.RawPatternMatcher;
+import tools.refinery.store.query.viatra.internal.pquery.Dnf2PQuery;
 
-import java.util.Collections;
-import java.util.LinkedHashMap;
-import java.util.Map;
+import java.util.*;
 import java.util.function.Function;
 
 public class ViatraModelQueryBuilderImpl extends AbstractModelAdapterBuilder implements ViatraModelQueryBuilder {
         private ViatraQueryEngineOptions.Builder engineOptionsBuilder;
-        private final DNF2PQuery dnf2PQuery = new DNF2PQuery();
-        private final Map<DNF, IQuerySpecification<RawPatternMatcher>> querySpecifications = new LinkedHashMap<>();
+        private QueryEvaluationHint defaultHint = new QueryEvaluationHint(Map.of(
+                        // Use a cost function that ignores the initial (empty) model but allows higher arity input keys.
+                        LocalSearchHintOptions.PLANNER_COST_FUNCTION, new FlatCostFunction()
+        ), (IQueryBackendFactory) null);
+        private final Dnf2PQuery dnf2PQuery = new Dnf2PQuery();
+        private final Set<AnyQuery> vacuousQueries = new LinkedHashSet<>();
+        private final Map<AnyQuery, IQuerySpecification<RawPatternMatcher>> querySpecifications = new LinkedHashMap<>();
 
         public ViatraModelQueryBuilderImpl(ModelStoreBuilder storeBuilder) {
                 super(storeBuilder);
                 engineOptionsBuilder = new ViatraQueryEngineOptions.Builder()
                                 .withDefaultBackend(ReteBackendFactory.INSTANCE)
                                 .withDefaultCachingBackend(ReteBackendFactory.INSTANCE)
-                                .withDefaultSearchBackend(LocalSearchGenericBackendFactory.INSTANCE);
+                                .withDefaultSearchBackend(RelationalLocalSearchBackendFactory.INSTANCE);
         }
 
         @Override
@@ -40,7 +46,7 @@ public class ViatraModelQueryBuilderImpl extends AbstractModelAdapterBuilder imp
 
         @Override
         public ViatraModelQueryBuilder defaultHint(QueryEvaluationHint queryEvaluationHint) {
-                engineOptionsBuilder.withDefaultHint(queryEvaluationHint);
+                defaultHint = defaultHint.overrideBy(queryEvaluationHint);
                 return this;
         }
 
@@ -63,44 +69,68 @@ public class ViatraModelQueryBuilderImpl extends AbstractModelAdapterBuilder imp
         }
 
         @Override
-        public ViatraModelQueryBuilder query(DNF query) {
-                if (querySpecifications.containsKey(query)) {
-                        throw new IllegalArgumentException("%s was already added to the query engine".formatted(query.name()));
+        public ViatraModelQueryBuilder query(AnyQuery query) {
+                if (querySpecifications.containsKey(query) || vacuousQueries.contains(query)) {
+                        // Ignore duplicate queries.
+                        return this;
+                }
+                var dnf = query.getDnf();
+                var reduction = dnf.getReduction();
+                switch (reduction) {
+                case NOT_REDUCIBLE -> {
+                        var pQuery = dnf2PQuery.translate(dnf);
+                        querySpecifications.put(query, pQuery.build());
+                }
+                case ALWAYS_FALSE -> vacuousQueries.add(query);
+                case ALWAYS_TRUE -> throw new IllegalArgumentException(
+                                "Query %s is relationally unsafe (it matches every tuple)".formatted(query.name()));
+                default -> throw new IllegalArgumentException("Unknown reduction: " + reduction);
                 }
-                var pQuery = dnf2PQuery.translate(query);
-                querySpecifications.put(query, pQuery.build());
                 return this;
         }
 
         @Override
-        public ViatraModelQueryBuilder query(DNF query, QueryEvaluationHint queryEvaluationHint) {
+        public ViatraModelQueryBuilder query(AnyQuery query, QueryEvaluationHint queryEvaluationHint) {
+                hint(query.getDnf(), queryEvaluationHint);
                 query(query);
-                hint(query, queryEvaluationHint);
                 return this;
         }
 
         @Override
-        public ViatraModelQueryBuilder computeHint(Function<DNF, QueryEvaluationHint> computeHint) {
+        public ViatraModelQueryBuilder computeHint(Function<Dnf, QueryEvaluationHint> computeHint) {
                 dnf2PQuery.setComputeHint(computeHint);
                 return this;
         }
 
         @Override
-        public ViatraModelQueryBuilder hint(DNF dnf, QueryEvaluationHint queryEvaluationHint) {
-                var pQuery = dnf2PQuery.getAlreadyTranslated(dnf);
-                if (pQuery == null) {
-                        throw new IllegalArgumentException(
-                                        "Cannot specify hint for %s, because it was not added to the query engine".formatted(dnf.name()));
-                }
-                pQuery.setEvaluationHints(pQuery.getEvaluationHints().overrideBy(queryEvaluationHint));
+        public ViatraModelQueryBuilder hint(Dnf dnf, QueryEvaluationHint queryEvaluationHint) {
+                dnf2PQuery.hint(dnf, queryEvaluationHint);
                 return this;
         }
 
         @Override
         public ViatraModelQueryStoreAdapterImpl createStoreAdapter(ModelStore store) {
                 validateSymbols(store);
-                return new ViatraModelQueryStoreAdapterImpl(store, engineOptionsBuilder.build(), dnf2PQuery.getRelationViews(),
-                                Collections.unmodifiableMap(querySpecifications));
+                dnf2PQuery.assertNoUnusedHints();
+                return new ViatraModelQueryStoreAdapterImpl(store, buildEngineOptions(), dnf2PQuery.getRelationViews(),
+                                Collections.unmodifiableMap(querySpecifications), Collections.unmodifiableSet(vacuousQueries));
+        }
+
+        private ViatraQueryEngineOptions buildEngineOptions() {
+                // Workaround: manually override the default backend, because {@link ViatraQueryEngineOptions.Builder}
+                // ignores all backend requirements except {@code SPECIFIC}.
+                switch (defaultHint.getQueryBackendRequirementType()) {
+                case SPECIFIC -> engineOptionsBuilder.withDefaultBackend(defaultHint.getQueryBackendFactory());
+                case DEFAULT_CACHING -> engineOptionsBuilder.withDefaultBackend(
+                                engineOptionsBuilder.build().getDefaultCachingBackendFactory());
+                case DEFAULT_SEARCH -> engineOptionsBuilder.withDefaultBackend(
+                                engineOptionsBuilder.build().getDefaultSearchBackendFactory());
+                case UNSPECIFIED -> {
+                        // Nothing to do, leave the default backend unchanged.
+                }
+                }
+                engineOptionsBuilder.withDefaultHint(defaultHint);
+                return engineOptionsBuilder.build();
         }
 
         private void validateSymbols(ModelStore store) {
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryStoreAdapterImpl.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryStoreAdapterImpl.java
index 394e407e..04c48c43 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryStoreAdapterImpl.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryStoreAdapterImpl.java
@@ -5,27 +5,34 @@ import org.eclipse.viatra.query.runtime.api.ViatraQueryEngineOptions;
 import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.query.DNF;
+import tools.refinery.store.query.dnf.AnyQuery;
 import tools.refinery.store.query.viatra.ViatraModelQueryStoreAdapter;
-import tools.refinery.store.query.viatra.internal.pquery.RawPatternMatcher;
+import tools.refinery.store.query.viatra.internal.matcher.RawPatternMatcher;
 import tools.refinery.store.query.view.AnyRelationView;
 
-import java.util.Collection;
-import java.util.Map;
+import java.util.*;
 
 public class ViatraModelQueryStoreAdapterImpl implements ViatraModelQueryStoreAdapter {
         private final ModelStore store;
         private final ViatraQueryEngineOptions engineOptions;
         private final Map<AnyRelationView, IInputKey> inputKeys;
-        private final Map<DNF, IQuerySpecification<RawPatternMatcher>> querySpecifications;
+        private final Map<AnyQuery, IQuerySpecification<RawPatternMatcher>> querySpecifications;
+        private final Set<AnyQuery> vacuousQueries;
+        private final Set<AnyQuery> allQueries;
 
         ViatraModelQueryStoreAdapterImpl(ModelStore store, ViatraQueryEngineOptions engineOptions,
                                                                          Map<AnyRelationView, IInputKey> inputKeys,
-                                                                         Map<DNF, IQuerySpecification<RawPatternMatcher>> querySpecifications) {
+                                                                         Map<AnyQuery, IQuerySpecification<RawPatternMatcher>> querySpecifications,
+                                                                         Set<AnyQuery> vacuousQueries) {
                 this.store = store;
                 this.engineOptions = engineOptions;
                 this.inputKeys = inputKeys;
                 this.querySpecifications = querySpecifications;
+                this.vacuousQueries = vacuousQueries;
+                var mutableAllQueries = new LinkedHashSet<AnyQuery>(querySpecifications.size() + vacuousQueries.size());
+                mutableAllQueries.addAll(querySpecifications.keySet());
+                mutableAllQueries.addAll(vacuousQueries);
+                this.allQueries = Collections.unmodifiableSet(mutableAllQueries);
         }
 
         @Override
@@ -42,14 +49,18 @@ public class ViatraModelQueryStoreAdapterImpl implements ViatraModelQueryStoreAd
         }
 
         @Override
-        public Collection<DNF> getQueries() {
-                return querySpecifications.keySet();
+        public Collection<AnyQuery> getQueries() {
+                return allQueries;
         }
 
-        Map<DNF, IQuerySpecification<RawPatternMatcher>> getQuerySpecifications() {
+        Map<AnyQuery, IQuerySpecification<RawPatternMatcher>> getQuerySpecifications() {
                 return querySpecifications;
         }
 
+        Set<AnyQuery> getVacuousQueries() {
+                return vacuousQueries;
+        }
+
         @Override
         public ViatraQueryEngineOptions getEngineOptions() {
                 return engineOptions;
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalQueryMetaContext.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalQueryMetaContext.java
index cba3fa08..d2c6beb4 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalQueryMetaContext.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalQueryMetaContext.java
@@ -3,6 +3,8 @@ package tools.refinery.store.query.viatra.internal.context;
 import org.eclipse.viatra.query.runtime.matchers.context.AbstractQueryMetaContext;
 import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
 import org.eclipse.viatra.query.runtime.matchers.context.InputKeyImplication;
+import org.eclipse.viatra.query.runtime.matchers.context.common.JavaTransitiveInstancesKey;
+import tools.refinery.store.query.term.DataSort;
 import tools.refinery.store.query.viatra.internal.pquery.RelationViewWrapper;
 import tools.refinery.store.query.view.AnyRelationView;
 
@@ -37,6 +39,9 @@ public class RelationalQueryMetaContext extends AbstractQueryMetaContext {
 
         @Override
         public Collection<InputKeyImplication> getImplications(IInputKey implyingKey) {
+                if (implyingKey instanceof JavaTransitiveInstancesKey) {
+                        return List.of();
+                }
                 var relationView = checkKey(implyingKey);
                 var relationViewImplications = relationView.getImpliedRelationViews();
                 var inputKeyImplications = new HashSet<InputKeyImplication>(relationViewImplications.size());
@@ -52,11 +57,25 @@ public class RelationalQueryMetaContext extends AbstractQueryMetaContext {
                                                 relationViewImplication.impliedIndices()));
                         }
                 }
+                var sorts = relationView.getSorts();
+                int arity = relationView.arity();
+                for (int i = 0; i < arity; i++) {
+                        var sort = sorts.get(i);
+                        if (sort instanceof DataSort<?> dataSort) {
+                                var javaTransitiveInstancesKey = new JavaTransitiveInstancesKey(dataSort.type());
+                                var javaImplication = new InputKeyImplication(implyingKey, javaTransitiveInstancesKey,
+                                                List.of(i));
+                                inputKeyImplications.add(javaImplication);
+                        }
+                }
                 return inputKeyImplications;
         }
 
         @Override
         public Map<Set<Integer>, Set<Integer>> getFunctionalDependencies(IInputKey key) {
+                if (key instanceof JavaTransitiveInstancesKey) {
+                        return Map.of();
+                }
                 var relationView = checkKey(key);
                 var functionalDependencies = relationView.getFunctionalDependencies();
                 var flattened = new HashMap<Set<Integer>, Set<Integer>>(functionalDependencies.size());
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java
index 01d20d3e..854817b1 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java
@@ -54,7 +54,8 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
 
         @Override
         public boolean isIndexed(IInputKey key, IndexingService service) {
-                if (key instanceof AnyRelationView relationalKey) {
+                if (key instanceof RelationViewWrapper wrapper) {
+                        var relationalKey = wrapper.getWrappedKey();
                         return this.modelUpdateListener.containsRelationView(relationalKey);
                 } else {
                         return false;
@@ -83,10 +84,7 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
 
         @Override
         public int countTuples(IInputKey key, TupleMask seedMask, ITuple seed) {
-                var relationViewKey = checkKey(key);
-                Iterable<Object[]> allObjects = relationViewKey.getAll(model);
-                Iterable<Object[]> filteredBySeed = filter(allObjects, objectArray -> isMatching(objectArray, seedMask, seed));
-                Iterator<Object[]> iterator = filteredBySeed.iterator();
+                Iterator<Object[]> iterator = enumerate(key, seedMask, seed).iterator();
                 int result = 0;
                 while (iterator.hasNext()) {
                         iterator.next();
@@ -102,13 +100,25 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
 
         @Override
         public Iterable<Tuple> enumerateTuples(IInputKey key, TupleMask seedMask, ITuple seed) {
+                var filteredBySeed = enumerate(key, seedMask, seed);
+                return map(filteredBySeed, Tuples::flatTupleOf);
+        }
+
+        @Override
+        public Iterable<?> enumerateValues(IInputKey key, TupleMask seedMask, ITuple seed) {
+                var index = seedMask.getFirstOmittedIndex().orElseThrow(
+                                () -> new IllegalArgumentException("Seed mask does not omit a value"));
+                var filteredBySeed = enumerate(key, seedMask, seed);
+                return map(filteredBySeed, array -> array[index]);
+        }
+
+        private Iterable<Object[]> enumerate(IInputKey key, TupleMask seedMask, ITuple seed) {
                 var relationViewKey = checkKey(key);
                 Iterable<Object[]> allObjects = relationViewKey.getAll(model);
-                Iterable<Object[]> filteredBySeed = filter(allObjects, objectArray -> isMatching(objectArray, seedMask, seed));
-                return map(filteredBySeed, Tuples::flatTupleOf);
+                return filter(allObjects, objectArray -> isMatching(objectArray, seedMask, seed));
         }
 
-        private boolean isMatching(Object[] tuple, TupleMask seedMask, ITuple seed) {
+        private static boolean isMatching(Object[] tuple, TupleMask seedMask, ITuple seed) {
                 for (int i = 0; i < seedMask.indices.length; i++) {
                         final Object seedElement = seed.get(i);
                         final Object tupleElement = tuple[seedMask.indices[i]];
@@ -120,11 +130,6 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
         }
 
         @Override
-        public Iterable<?> enumerateValues(IInputKey key, TupleMask seedMask, ITuple seed) {
-                return enumerateTuples(key, seedMask, seed);
-        }
-
-        @Override
         public boolean containsTuple(IInputKey key, ITuple seed) {
                 var relationViewKey = checkKey(key);
                 return relationViewKey.get(model, seed.getElements());
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/ExtendOperationExecutor.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/ExtendOperationExecutor.java
new file mode 100644
index 00000000..2d3dd5a7
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/ExtendOperationExecutor.java
@@ -0,0 +1,75 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, Akos Horvath, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.store.query.viatra.internal.localsearch;
+
+import org.eclipse.viatra.query.runtime.localsearch.MatchingFrame;
+import org.eclipse.viatra.query.runtime.localsearch.matcher.ISearchContext;
+import org.eclipse.viatra.query.runtime.localsearch.operations.ISearchOperation.ISearchOperationExecutor;
+
+import java.util.Iterator;
+
+/**
+ * An operation that can be used to enumerate all possible values for a single position based on a constraint
+ * @author Zoltan Ujhelyi, Akos Horvath
+ * @since 2.0
+ */
+abstract class ExtendOperationExecutor<T> implements ISearchOperationExecutor {
+
+    private Iterator<? extends T> it;
+
+    /**
+     * Returns an iterator with the possible options from the current state
+     * @since 2.0
+     */
+        @SuppressWarnings("squid:S1452")
+    protected abstract Iterator<? extends T> getIterator(MatchingFrame frame, ISearchContext context);
+    /**
+     * Updates the frame with the next element of the iterator. Called during {@link #execute(MatchingFrame, ISearchContext)}.
+     *
+     * @return true if the update is successful or false otherwise; in case of false is returned, the next element should be taken from the iterator.
+     * @since 2.0
+     */
+    protected abstract boolean fillInValue(T newValue, MatchingFrame frame, ISearchContext context);
+
+    /**
+     * Restores the frame to the state before {@link #fillInValue(Object, MatchingFrame, ISearchContext)}. Called during
+     * {@link #onBacktrack(MatchingFrame, ISearchContext)}.
+     *
+     * @since 2.0
+     */
+    protected abstract void cleanup(MatchingFrame frame, ISearchContext context);
+
+    @Override
+    public void onInitialize(MatchingFrame frame, ISearchContext context) {
+        it = getIterator(frame, context);
+    }
+
+    @Override
+    public void onBacktrack(MatchingFrame frame, ISearchContext context) {
+        it = null;
+
+    }
+
+        /**
+         * Fixed version of {@link org.eclipse.viatra.query.runtime.localsearch.operations.ExtendOperationExecutor#execute}
+         * that handles failed unification of variables correctly.
+         * @param frame The matching frame to extend.
+         * @param context The search context.
+         * @return {@code true} if an extension was found, {@code false} otherwise.
+         */
+    @Override
+    public boolean execute(MatchingFrame frame, ISearchContext context) {
+                while (it.hasNext()) {
+                        var newValue = it.next();
+                        if (fillInValue(newValue, frame, context)) {
+                                return true;
+                        }
+                }
+                return false;
+    }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/ExtendPositivePatternCall.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/ExtendPositivePatternCall.java
new file mode 100644
index 00000000..aaaece80
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/ExtendPositivePatternCall.java
@@ -0,0 +1,116 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQueryLabs
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.store.query.viatra.internal.localsearch;
+
+import org.eclipse.viatra.query.runtime.localsearch.MatchingFrame;
+import org.eclipse.viatra.query.runtime.localsearch.matcher.ISearchContext;
+import org.eclipse.viatra.query.runtime.localsearch.operations.IPatternMatcherOperation;
+import org.eclipse.viatra.query.runtime.localsearch.operations.ISearchOperation;
+import org.eclipse.viatra.query.runtime.localsearch.operations.util.CallInformation;
+import org.eclipse.viatra.query.runtime.matchers.backend.IQueryResultProvider;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.TupleMask;
+import org.eclipse.viatra.query.runtime.matchers.tuple.VolatileModifiableMaskedTuple;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+
+/**
+ * @author Grill Balázs
+ * @since 1.4
+ *
+ */
+public class ExtendPositivePatternCall implements ISearchOperation, IPatternMatcherOperation {
+
+    private class Executor extends ExtendOperationExecutor<Tuple> {
+        private final VolatileModifiableMaskedTuple maskedTuple;
+
+        public Executor() {
+            maskedTuple = new VolatileModifiableMaskedTuple(information.getThinFrameMask());
+        }
+
+        @Override
+        protected Iterator<? extends Tuple> getIterator(MatchingFrame frame, ISearchContext context) {
+            maskedTuple.updateTuple(frame);
+            IQueryResultProvider matcher = context.getMatcher(information.getCallWithAdornment());
+            return matcher.getAllMatches(information.getParameterMask(), maskedTuple).iterator();
+        }
+
+        /**
+         * @since 2.0
+         */
+        @Override
+        protected boolean fillInValue(Tuple result, MatchingFrame frame, ISearchContext context) {
+            TupleMask mask = information.getFullFrameMask();
+            // The first loop clears out the elements from a possible previous iteration
+            for(int i : information.getFreeParameterIndices()) {
+                mask.set(frame, i, null);
+            }
+            for(int i : information.getFreeParameterIndices()) {
+                Object oldValue = mask.getValue(frame, i);
+                Object valueToFill = result.get(i);
+                if (oldValue != null && !oldValue.equals(valueToFill)){
+                    // If the inverse map contains more than one values for the same key, it means that these arguments are unified by the caller.
+                    // In this case if the callee assigns different values the frame shall be dropped
+                    return false;
+                }
+                mask.set(frame, i, valueToFill);
+            }
+            return true;
+        }
+
+        @Override
+        protected void cleanup(MatchingFrame frame, ISearchContext context) {
+            TupleMask mask = information.getFullFrameMask();
+            for(int i : information.getFreeParameterIndices()){
+                mask.set(frame, i, null);
+            }
+
+        }
+
+        @Override
+        public ISearchOperation getOperation() {
+            return ExtendPositivePatternCall.this;
+        }
+    }
+
+    private final CallInformation information;
+
+    /**
+     * @since 1.7
+     */
+    public ExtendPositivePatternCall(CallInformation information) {
+       this.information = information;
+    }
+
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor();
+    }
+
+    @Override
+    public List<Integer> getVariablePositions() {
+        return information.getVariablePositions();
+    }
+
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+
+    @Override
+    public String toString(@SuppressWarnings("squid:S4276") Function<Integer, String> variableMapping) {
+        return "extend find " + information.toString(variableMapping);
+    }
+
+    @Override
+    public CallInformation getCallInformation() {
+        return information;
+    }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/FlatCostFunction.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/FlatCostFunction.java
new file mode 100644
index 00000000..84cab142
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/FlatCostFunction.java
@@ -0,0 +1,30 @@
+package tools.refinery.store.query.viatra.internal.localsearch;
+
+import org.eclipse.viatra.query.runtime.localsearch.planner.cost.IConstraintEvaluationContext;
+import org.eclipse.viatra.query.runtime.localsearch.planner.cost.impl.StatisticsBasedConstraintCostFunction;
+import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.tuple.TupleMask;
+import org.eclipse.viatra.query.runtime.matchers.util.Accuracy;
+
+import java.util.Optional;
+
+public class FlatCostFunction extends StatisticsBasedConstraintCostFunction {
+        public FlatCostFunction() {
+                // No inverse navigation penalty thanks to relational storage.
+                super(0);
+        }
+
+        @Override
+        public Optional<Long> projectionSize(IConstraintEvaluationContext input, IInputKey supplierKey, TupleMask groupMask, Accuracy requiredAccuracy) {
+                // We always start from an empty model, where every projection is of size 0.
+                // Therefore, projection size estimation is meaningless.
+                return Optional.empty();
+        }
+
+        @Override
+        protected double _calculateCost(TypeConstraint constraint, IConstraintEvaluationContext input) {
+                // Assume a flat cost for each relation. Maybe adjust in the future if we perform indexing?
+                return DEFAULT_COST;
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/GenericTypeExtend.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/GenericTypeExtend.java
new file mode 100644
index 00000000..64653658
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/GenericTypeExtend.java
@@ -0,0 +1,136 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.store.query.viatra.internal.localsearch;
+
+import org.eclipse.viatra.query.runtime.localsearch.MatchingFrame;
+import org.eclipse.viatra.query.runtime.localsearch.matcher.ISearchContext;
+import org.eclipse.viatra.query.runtime.localsearch.operations.IIteratingSearchOperation;
+import org.eclipse.viatra.query.runtime.localsearch.operations.ISearchOperation;
+import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.TupleMask;
+import org.eclipse.viatra.query.runtime.matchers.tuple.VolatileMaskedTuple;
+import org.eclipse.viatra.query.runtime.matchers.util.Preconditions;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ */
+public class GenericTypeExtend implements IIteratingSearchOperation {
+    private class Executor extends ExtendOperationExecutor<Tuple> {
+        private final VolatileMaskedTuple maskedTuple;
+
+        public Executor() {
+            this.maskedTuple = new VolatileMaskedTuple(callMask);
+        }
+
+        @Override
+        protected Iterator<? extends Tuple> getIterator(MatchingFrame frame, ISearchContext context) {
+            maskedTuple.updateTuple(frame);
+            return context.getRuntimeContext().enumerateTuples(type, indexerMask, maskedTuple).iterator();
+        }
+
+        @Override
+        protected boolean fillInValue(Tuple newTuple, MatchingFrame frame, ISearchContext context) {
+            for (Integer position : unboundVariableIndices) {
+                frame.setValue(position, null);
+            }
+            for (int i = 0; i < positions.length; i++) {
+                Object newValue = newTuple.get(i);
+                Object oldValue = frame.getValue(positions[i]);
+                if (oldValue != null && !Objects.equals(oldValue, newValue)) {
+                    // If positions tuple maps more than one values for the same element (e.g. loop), it means that
+                    // these arguments are to unified by the caller. In this case if the callee assigns different values
+                    // the frame shall be considered a failed match
+                    return false;
+                }
+                frame.setValue(positions[i], newValue);
+            }
+            return true;
+        }
+
+        @Override
+        protected void cleanup(MatchingFrame frame, ISearchContext context) {
+            for (Integer position : unboundVariableIndices) {
+                frame.setValue(position, null);
+            }
+        }
+
+                @Override
+        public ISearchOperation getOperation() {
+            return GenericTypeExtend.this;
+        }
+    }
+
+    private final IInputKey type;
+    private final int[] positions;
+    private final List<Integer> positionList;
+    private final Set<Integer> unboundVariableIndices;
+    private final TupleMask indexerMask;
+    private final TupleMask callMask;
+
+    /**
+     *
+     * @param type
+     *            the type to execute the extend operation on
+     * @param positions
+     *            the parameter positions that represent the variables of the input key
+     * @param unboundVariableIndices
+     *            the set of positions that are bound at the start of the operation
+     */
+    public GenericTypeExtend(IInputKey type, int[] positions, TupleMask callMask, TupleMask indexerMask, Set<Integer> unboundVariableIndices) {
+        Preconditions.checkArgument(positions.length == type.getArity(),
+                "The type %s requires %d parameters, but %d positions are provided", type.getPrettyPrintableName(),
+                type.getArity(), positions.length);
+        List<Integer> modifiablePositionList = new ArrayList<>();
+        for (int position : positions) {
+            modifiablePositionList.add(position);
+        }
+        this.positionList = Collections.unmodifiableList(modifiablePositionList);
+        this.positions = positions;
+        this.type = type;
+
+        this.unboundVariableIndices = unboundVariableIndices;
+        this.indexerMask = indexerMask;
+        this.callMask = callMask;
+    }
+
+    @Override
+    public IInputKey getIteratedInputKey() {
+        return type;
+    }
+
+    @Override
+    public ISearchOperationExecutor createExecutor() {
+        return new Executor();
+    }
+
+    @Override
+    public List<Integer> getVariablePositions() {
+        return positionList;
+    }
+
+    @Override
+    public String toString() {
+        return toString(Object::toString);
+    }
+
+    @Override
+    public String toString(@SuppressWarnings("squid:S4276") Function<Integer, String> variableMapping) {
+        return "extend    " + type.getPrettyPrintableName() + "("
+                + positionList.stream()
+                        .map(input -> String.format("%s%s", unboundVariableIndices.contains(input) ? "-" : "+", variableMapping.apply(input)))
+                        .collect(Collectors.joining(", "))
+                + ")";
+    }
+
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/RelationalLocalSearchBackendFactory.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/RelationalLocalSearchBackendFactory.java
new file mode 100644
index 00000000..156eb313
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/RelationalLocalSearchBackendFactory.java
@@ -0,0 +1,55 @@
+package tools.refinery.store.query.viatra.internal.localsearch;
+
+import org.eclipse.viatra.query.runtime.localsearch.matcher.integration.AbstractLocalSearchResultProvider;
+import org.eclipse.viatra.query.runtime.localsearch.matcher.integration.LocalSearchBackend;
+import org.eclipse.viatra.query.runtime.localsearch.matcher.integration.LocalSearchHints;
+import org.eclipse.viatra.query.runtime.localsearch.plan.IPlanProvider;
+import org.eclipse.viatra.query.runtime.localsearch.plan.SimplePlanProvider;
+import org.eclipse.viatra.query.runtime.matchers.backend.IMatcherCapability;
+import org.eclipse.viatra.query.runtime.matchers.backend.IQueryBackend;
+import org.eclipse.viatra.query.runtime.matchers.backend.IQueryBackendFactory;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.context.IQueryBackendContext;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery;
+
+public class RelationalLocalSearchBackendFactory implements IQueryBackendFactory {
+        public static final RelationalLocalSearchBackendFactory INSTANCE = new RelationalLocalSearchBackendFactory();
+
+        private RelationalLocalSearchBackendFactory() {
+        }
+
+        @Override
+        public IQueryBackend create(IQueryBackendContext context) {
+                return new LocalSearchBackend(context) {
+                        // Create a new {@link IPlanProvider}, because the original {@link LocalSearchBackend#planProvider} is not
+                        // accessible.
+                        private final IPlanProvider planProvider = new SimplePlanProvider(context.getLogger());
+
+                        @Override
+                        protected AbstractLocalSearchResultProvider initializeResultProvider(PQuery query,
+                                                                                                                                                                 QueryEvaluationHint hints) {
+                                return new RelationalLocalSearchResultProvider(this, context, query, planProvider, hints);
+                        }
+
+                        @Override
+                        public IQueryBackendFactory getFactory() {
+                                return RelationalLocalSearchBackendFactory.this;
+                        }
+                };
+        }
+
+        @Override
+        public Class<? extends IQueryBackend> getBackendClass() {
+                return LocalSearchBackend.class;
+        }
+
+        @Override
+        public IMatcherCapability calculateRequiredCapability(PQuery pQuery, QueryEvaluationHint queryEvaluationHint) {
+                return LocalSearchHints.parse(queryEvaluationHint);
+        }
+
+        @Override
+        public boolean isCaching() {
+                return false;
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/RelationalLocalSearchResultProvider.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/RelationalLocalSearchResultProvider.java
new file mode 100644
index 00000000..be2a38ca
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/RelationalLocalSearchResultProvider.java
@@ -0,0 +1,23 @@
+package tools.refinery.store.query.viatra.internal.localsearch;
+
+import org.eclipse.viatra.query.runtime.localsearch.matcher.integration.AbstractLocalSearchResultProvider;
+import org.eclipse.viatra.query.runtime.localsearch.matcher.integration.LocalSearchBackend;
+import org.eclipse.viatra.query.runtime.localsearch.matcher.integration.LocalSearchHints;
+import org.eclipse.viatra.query.runtime.localsearch.plan.IPlanProvider;
+import org.eclipse.viatra.query.runtime.localsearch.planner.compiler.IOperationCompiler;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.context.IQueryBackendContext;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery;
+
+class RelationalLocalSearchResultProvider extends AbstractLocalSearchResultProvider {
+        public RelationalLocalSearchResultProvider(LocalSearchBackend backend, IQueryBackendContext context, PQuery query,
+                                                                                           IPlanProvider planProvider, QueryEvaluationHint userHints) {
+                super(backend, context, query, planProvider, userHints);
+        }
+
+        @Override
+        protected IOperationCompiler getOperationCompiler(IQueryBackendContext backendContext,
+                                                                                                          LocalSearchHints configuration) {
+                return new RelationalOperationCompiler(runtimeContext);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/RelationalOperationCompiler.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/RelationalOperationCompiler.java
new file mode 100644
index 00000000..b6832b39
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/localsearch/RelationalOperationCompiler.java
@@ -0,0 +1,65 @@
+package tools.refinery.store.query.viatra.internal.localsearch;
+
+import org.eclipse.viatra.query.runtime.localsearch.operations.generic.GenericTypeExtendSingleValue;
+import org.eclipse.viatra.query.runtime.localsearch.operations.util.CallInformation;
+import org.eclipse.viatra.query.runtime.localsearch.planner.compiler.GenericOperationCompiler;
+import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
+import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContext;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.TupleMask;
+
+import java.util.*;
+
+public class RelationalOperationCompiler extends GenericOperationCompiler  {
+        public RelationalOperationCompiler(IQueryRuntimeContext runtimeContext) {
+                super(runtimeContext);
+        }
+
+        @Override
+        protected void createExtend(TypeConstraint typeConstraint, Map<PVariable, Integer> variableMapping) {
+                IInputKey inputKey = typeConstraint.getSupplierKey();
+                Tuple tuple = typeConstraint.getVariablesTuple();
+
+                int[] positions = new int[tuple.getSize()];
+                List<Integer> boundVariableIndices = new ArrayList<>();
+                List<Integer> boundVariables = new ArrayList<>();
+                Set<Integer> unboundVariables = new HashSet<>();
+                for (int i = 0; i < tuple.getSize(); i++) {
+                        PVariable variable = (PVariable) tuple.get(i);
+                        Integer position = variableMapping.get(variable);
+                        positions[i] = position;
+                        if (variableBindings.get(typeConstraint).contains(position)) {
+                                boundVariableIndices.add(i);
+                                boundVariables.add(position);
+                        } else {
+                                unboundVariables.add(position);
+                        }
+                }
+                TupleMask indexerMask = TupleMask.fromSelectedIndices(inputKey.getArity(), boundVariableIndices);
+                TupleMask callMask = TupleMask.fromSelectedIndices(variableMapping.size(), boundVariables);
+                // If multiple tuple elements from the indexer should be bound to the same variable, we must use a
+                // {@link GenericTypeExtend} check whether the tuple elements have the same value.
+                if (unboundVariables.size() == 1 && indexerMask.getSize() + 1 == indexerMask.getSourceWidth()) {
+                        operations.add(new GenericTypeExtendSingleValue(inputKey, positions, callMask, indexerMask,
+                                        unboundVariables.iterator().next()));
+                } else {
+                        // Use a fixed version of
+                        // {@code org.eclipse.viatra.query.runtime.localsearch.operations.generic.GenericTypeExtend} that handles
+                        // failed unification of variables correctly.
+                        operations.add(new GenericTypeExtend(inputKey, positions, callMask, indexerMask, unboundVariables));
+                }
+        }
+
+        @Override
+        protected void createExtend(PositivePatternCall pCall, Map<PVariable, Integer> variableMapping) {
+                CallInformation information = CallInformation.create(pCall, variableMapping, variableBindings.get(pCall));
+                // Use a fixed version of
+                // {@code org.eclipse.viatra.query.runtime.localsearch.operations.extend.ExtendPositivePatternCall} that handles
+                // failed unification of variables correctly.
+                operations.add(new ExtendPositivePatternCall(information));
+                dependencies.add(information.getCallWithAdornment());
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalCursor.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalCursor.java
new file mode 100644
index 00000000..4daa14a1
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalCursor.java
@@ -0,0 +1,48 @@
+package tools.refinery.store.query.viatra.internal.matcher;
+
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.rete.index.IterableIndexer;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.tuple.TupleLike;
+
+import java.util.Iterator;
+
+class FunctionalCursor<T> implements Cursor<TupleLike, T> {
+        private final IterableIndexer indexer;
+        private final Iterator<Tuple> iterator;
+        private boolean terminated;
+        private TupleLike key;
+        private T value;
+
+        public FunctionalCursor(IterableIndexer indexer) {
+                this.indexer = indexer;
+                iterator = indexer.getSignatures().iterator();
+        }
+
+        @Override
+        public TupleLike getKey() {
+                return key;
+        }
+
+        @Override
+        public T getValue() {
+                return value;
+        }
+
+        @Override
+        public boolean isTerminated() {
+                return terminated;
+        }
+
+        @Override
+        public boolean move() {
+                if (!terminated && iterator.hasNext()) {
+                        var match = iterator.next();
+                        key = new ViatraTupleLike(match);
+                        value = MatcherUtils.getSingleValue(indexer.get(match));
+                        return true;
+                }
+                terminated = true;
+                return false;
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalViatraMatcher.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalViatraMatcher.java
new file mode 100644
index 00000000..6aa45af2
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalViatraMatcher.java
@@ -0,0 +1,91 @@
+package tools.refinery.store.query.viatra.internal.matcher;
+
+import org.eclipse.viatra.query.runtime.matchers.backend.IQueryResultProvider;
+import org.eclipse.viatra.query.runtime.matchers.tuple.TupleMask;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.rete.index.IterableIndexer;
+import org.eclipse.viatra.query.runtime.rete.matcher.RetePatternMatcher;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.ResultSet;
+import tools.refinery.store.query.dnf.FunctionalQuery;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
+import tools.refinery.store.tuple.TupleLike;
+
+/**
+ * Directly access the tuples inside a VIATRA pattern matcher.<p>
+ * This class neglects calling
+ * {@link org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContext#wrapTuple(org.eclipse.viatra.query.runtime.matchers.tuple.Tuple)}
+ * and
+ * {@link org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContext#unwrapTuple(org.eclipse.viatra.query.runtime.matchers.tuple.Tuple)},
+ * because {@link tools.refinery.store.query.viatra.internal.context.RelationalRuntimeContext} provides a trivial
+ * implementation for these methods.
+ * Using this class with any other runtime context may lead to undefined behavior.
+ */
+public class FunctionalViatraMatcher<T> implements ResultSet<T> {
+        private final ViatraModelQueryAdapterImpl adapter;
+        private final FunctionalQuery<T> query;
+        private final TupleMask emptyMask;
+        private final TupleMask omitOutputMask;
+        private final IQueryResultProvider backend;
+        private final IterableIndexer omitOutputIndexer;
+
+        public FunctionalViatraMatcher(ViatraModelQueryAdapterImpl adapter, FunctionalQuery<T> query,
+                                                                   RawPatternMatcher rawPatternMatcher) {
+                this.adapter = adapter;
+                this.query = query;
+                int arity = query.arity();
+                int arityWithOutput = arity + 1;
+                emptyMask = TupleMask.empty(arityWithOutput);
+                omitOutputMask = TupleMask.omit(arity, arityWithOutput);
+                backend = rawPatternMatcher.getBackend();
+                if (backend instanceof RetePatternMatcher reteBackend) {
+                        var maybeIterableOmitOutputIndexer = IndexerUtils.getIndexer(reteBackend, omitOutputMask);
+                        if (maybeIterableOmitOutputIndexer instanceof IterableIndexer iterableOmitOutputIndexer) {
+                                omitOutputIndexer = iterableOmitOutputIndexer;
+                        } else {
+                                omitOutputIndexer = null;
+                        }
+                } else {
+                        omitOutputIndexer = null;
+                }
+        }
+
+        @Override
+        public ModelQueryAdapter getAdapter() {
+                return adapter;
+        }
+
+        @Override
+        public Query<T> getQuery() {
+                return query;
+        }
+
+        @Override
+        public T get(TupleLike parameters) {
+                var tuple = MatcherUtils.toViatraTuple(parameters);
+                if (omitOutputIndexer == null) {
+                        return MatcherUtils.getSingleValue(backend.getAllMatches(omitOutputMask, tuple).iterator());
+                } else {
+                        return MatcherUtils.getSingleValue(omitOutputIndexer.get(tuple));
+                }
+        }
+
+        @Override
+        public Cursor<TupleLike, T> getAll() {
+                if (omitOutputIndexer == null) {
+                        var allMatches = backend.getAllMatches(emptyMask, Tuples.staticArityFlatTupleOf());
+                        return new UnsafeFunctionalCursor<>(allMatches.iterator());
+                }
+                return new FunctionalCursor<>(omitOutputIndexer);
+        }
+
+        @Override
+        public int size() {
+                if (omitOutputIndexer == null) {
+                        return backend.countMatches(emptyMask, Tuples.staticArityFlatTupleOf());
+                }
+                return omitOutputIndexer.getBucketCount();
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/IndexerUtils.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/IndexerUtils.java
new file mode 100644
index 00000000..55eb8c44
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/IndexerUtils.java
@@ -0,0 +1,48 @@
+package tools.refinery.store.query.viatra.internal.matcher;
+
+import org.eclipse.viatra.query.runtime.matchers.tuple.TupleMask;
+import org.eclipse.viatra.query.runtime.rete.index.Indexer;
+import org.eclipse.viatra.query.runtime.rete.matcher.ReteEngine;
+import org.eclipse.viatra.query.runtime.rete.matcher.RetePatternMatcher;
+import org.eclipse.viatra.query.runtime.rete.traceability.RecipeTraceInfo;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+
+final class IndexerUtils {
+    private static final MethodHandle GET_ENGINE_HANDLE;
+    private static final MethodHandle GET_PRODUCTION_NODE_TRACE_HANDLE;
+    private static final MethodHandle ACCESS_PROJECTION_HANDLE;
+
+    static {
+        try {
+            var lookup = MethodHandles.privateLookupIn(RetePatternMatcher.class, MethodHandles.lookup());
+            GET_ENGINE_HANDLE = lookup.findGetter(RetePatternMatcher.class, "engine", ReteEngine.class);
+            GET_PRODUCTION_NODE_TRACE_HANDLE = lookup.findGetter(RetePatternMatcher.class, "productionNodeTrace",
+                    RecipeTraceInfo.class);
+            ACCESS_PROJECTION_HANDLE = lookup.findVirtual(ReteEngine.class, "accessProjection",
+                    MethodType.methodType(Indexer.class, RecipeTraceInfo.class, TupleMask.class));
+        } catch (IllegalAccessException | NoSuchFieldException | NoSuchMethodException e) {
+            throw new IllegalStateException("Cannot access private members of %s"
+                    .formatted(RetePatternMatcher.class.getPackageName()), e);
+        }
+    }
+
+    private IndexerUtils() {
+        throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+    }
+
+    public static Indexer getIndexer(RetePatternMatcher backend, TupleMask mask) {
+        try {
+            var engine = (ReteEngine) GET_ENGINE_HANDLE.invokeExact(backend);
+            var trace = (RecipeTraceInfo) GET_PRODUCTION_NODE_TRACE_HANDLE.invokeExact(backend);
+            return (Indexer) ACCESS_PROJECTION_HANDLE.invokeExact(engine, trace, mask);
+        } catch (Error e) {
+            // Fatal JVM errors should not be wrapped.
+            throw e;
+        } catch (Throwable e) {
+            throw new IllegalStateException("Cannot access matcher for mask " + mask, e);
+        }
+    }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/MatcherUtils.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/MatcherUtils.java
new file mode 100644
index 00000000..5d4be95d
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/MatcherUtils.java
@@ -0,0 +1,50 @@
+package tools.refinery.store.query.viatra.internal.matcher;
+
+import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.TupleLike;
+
+import java.util.Iterator;
+
+final class MatcherUtils {
+        private MatcherUtils() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static org.eclipse.viatra.query.runtime.matchers.tuple.Tuple toViatraTuple(TupleLike tuple) {
+                if (tuple instanceof ViatraTupleLike viatraTupleLike) {
+                        return viatraTupleLike.wrappedTuple().toImmutable();
+                }
+                int size = tuple.getSize();
+                var array = new Object[size];
+                for (int i = 0; i < size; i++) {
+                        var value = tuple.get(i);
+                        array[i] = Tuple.of(value);
+                }
+                return Tuples.flatTupleOf(array);
+        }
+
+
+        public static <T> T getSingleValue(@Nullable Iterable<? extends ITuple> tuples) {
+                if (tuples == null) {
+                        return null;
+                }
+                return getSingleValue(tuples.iterator());
+        }
+
+        public static <T> T getSingleValue(Iterator<? extends ITuple> iterator) {
+                if (!iterator.hasNext()) {
+                        return null;
+                }
+                var match = iterator.next();
+                @SuppressWarnings("unchecked")
+                var result = (T) match.get(match.getSize() - 1);
+                if (iterator.hasNext()) {
+                        var input = new OmitOutputViatraTupleLike(match);
+                        throw new IllegalStateException("Query is not functional for input tuple: " + input);
+                }
+                return result;
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/OmitOutputViatraTupleLike.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/OmitOutputViatraTupleLike.java
new file mode 100644
index 00000000..bd9301ba
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/OmitOutputViatraTupleLike.java
@@ -0,0 +1,23 @@
+package tools.refinery.store.query.viatra.internal.matcher;
+
+import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
+import tools.refinery.store.tuple.Tuple1;
+import tools.refinery.store.tuple.TupleLike;
+
+record OmitOutputViatraTupleLike(ITuple wrappedTuple) implements TupleLike {
+        @Override
+        public int getSize() {
+                return wrappedTuple.getSize() - 1;
+        }
+
+        @Override
+        public int get(int element) {
+                var wrappedValue = (Tuple1) wrappedTuple.get(element);
+                return wrappedValue.value0();
+        }
+
+        @Override
+        public String toString() {
+                return TupleLike.toString(this);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RawPatternMatcher.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RawPatternMatcher.java
new file mode 100644
index 00000000..b3d05967
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RawPatternMatcher.java
@@ -0,0 +1,15 @@
+package tools.refinery.store.query.viatra.internal.matcher;
+
+import org.eclipse.viatra.query.runtime.api.GenericPatternMatcher;
+import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification;
+import org.eclipse.viatra.query.runtime.matchers.backend.IQueryResultProvider;
+
+public class RawPatternMatcher extends GenericPatternMatcher {
+    public RawPatternMatcher(GenericQuerySpecification<? extends GenericPatternMatcher> specification) {
+        super(specification);
+    }
+
+        IQueryResultProvider getBackend() {
+                return backend;
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalCursor.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalCursor.java
new file mode 100644
index 00000000..c2dcc565
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalCursor.java
@@ -0,0 +1,42 @@
+package tools.refinery.store.query.viatra.internal.matcher;
+
+import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.tuple.TupleLike;
+
+import java.util.Iterator;
+
+class RelationalCursor implements Cursor<TupleLike, Boolean> {
+    private final Iterator<? extends ITuple> tuplesIterator;
+    private boolean terminated;
+    private TupleLike key;
+
+    public RelationalCursor(Iterator<? extends ITuple> tuplesIterator) {
+        this.tuplesIterator = tuplesIterator;
+    }
+
+    @Override
+    public TupleLike getKey() {
+        return key;
+    }
+
+    @Override
+    public Boolean getValue() {
+        return true;
+    }
+
+    @Override
+    public boolean isTerminated() {
+        return terminated;
+    }
+
+    @Override
+    public boolean move() {
+        if (!terminated && tuplesIterator.hasNext()) {
+            key = new ViatraTupleLike(tuplesIterator.next());
+            return true;
+        }
+        terminated = true;
+        return false;
+    }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalViatraMatcher.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalViatraMatcher.java
new file mode 100644
index 00000000..b9bc3f1e
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalViatraMatcher.java
@@ -0,0 +1,89 @@
+package tools.refinery.store.query.viatra.internal.matcher;
+
+import org.eclipse.viatra.query.runtime.matchers.backend.IQueryResultProvider;
+import org.eclipse.viatra.query.runtime.matchers.tuple.TupleMask;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.rete.index.Indexer;
+import org.eclipse.viatra.query.runtime.rete.matcher.RetePatternMatcher;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.Cursors;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.ResultSet;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.dnf.RelationalQuery;
+import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
+import tools.refinery.store.tuple.TupleLike;
+
+/**
+ * Directly access the tuples inside a VIATRA pattern matcher.<p>
+ * This class neglects calling
+ * {@link org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContext#wrapTuple(org.eclipse.viatra.query.runtime.matchers.tuple.Tuple)}
+ * and
+ * {@link org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContext#unwrapTuple(org.eclipse.viatra.query.runtime.matchers.tuple.Tuple)},
+ * because {@link tools.refinery.store.query.viatra.internal.context.RelationalRuntimeContext} provides a trivial
+ * implementation for these methods.
+ * Using this class with any other runtime context may lead to undefined behavior.
+ */
+public class RelationalViatraMatcher implements ResultSet<Boolean> {
+        private final ViatraModelQueryAdapterImpl adapter;
+        private final RelationalQuery query;
+        private final TupleMask emptyMask;
+        private final TupleMask identityMask;
+        private final IQueryResultProvider backend;
+        private final Indexer emptyMaskIndexer;
+
+        public RelationalViatraMatcher(ViatraModelQueryAdapterImpl adapter, RelationalQuery query,
+                                                                   RawPatternMatcher rawPatternMatcher) {
+                this.adapter = adapter;
+                this.query = query;
+                int arity = query.arity();
+                emptyMask = TupleMask.empty(arity);
+                identityMask = TupleMask.identity(arity);
+                backend = rawPatternMatcher.getBackend();
+                if (backend instanceof RetePatternMatcher reteBackend) {
+                        emptyMaskIndexer = IndexerUtils.getIndexer(reteBackend, emptyMask);
+                } else {
+                        emptyMaskIndexer = null;
+                }
+        }
+
+        @Override
+        public ModelQueryAdapter getAdapter() {
+                return adapter;
+        }
+
+        @Override
+        public Query<Boolean> getQuery() {
+                return query;
+        }
+
+        @Override
+        public Boolean get(TupleLike parameters) {
+                var tuple = MatcherUtils.toViatraTuple(parameters);
+                if (emptyMaskIndexer == null) {
+                        return backend.hasMatch(identityMask, tuple);
+                }
+                var matches = emptyMaskIndexer.get(Tuples.staticArityFlatTupleOf());
+                return matches != null && matches.contains(tuple);
+        }
+
+        @Override
+        public Cursor<TupleLike, Boolean> getAll() {
+                if (emptyMaskIndexer == null) {
+                        var allMatches = backend.getAllMatches(emptyMask, Tuples.staticArityFlatTupleOf());
+                        return new RelationalCursor(allMatches.iterator());
+                }
+                var matches = emptyMaskIndexer.get(Tuples.staticArityFlatTupleOf());
+                return matches == null ? Cursors.empty() : new RelationalCursor(matches.stream().iterator());
+        }
+
+        @Override
+        public int size() {
+                if (emptyMaskIndexer == null) {
+                        return backend.countMatches(emptyMask, Tuples.staticArityFlatTupleOf());
+                }
+                var matches = emptyMaskIndexer.get(Tuples.staticArityFlatTupleOf());
+                return matches == null ? 0 : matches.size();
+        }
+
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/UnsafeFunctionalCursor.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/UnsafeFunctionalCursor.java
new file mode 100644
index 00000000..6c53fff1
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/UnsafeFunctionalCursor.java
@@ -0,0 +1,52 @@
+package tools.refinery.store.query.viatra.internal.matcher;
+
+import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.tuple.TupleLike;
+
+import java.util.Iterator;
+
+/**
+ * Cursor for a functional result set that iterates over a stream of raw matches and doesn't check whether the
+ * functional dependency of the output on the inputs is obeyed.
+ * @param <T> The output type.
+ */
+class UnsafeFunctionalCursor<T> implements Cursor<TupleLike, T> {
+        private final Iterator<? extends ITuple> tuplesIterator;
+        private boolean terminated;
+        private TupleLike key;
+        private T value;
+
+        public UnsafeFunctionalCursor(Iterator<? extends ITuple> tuplesIterator) {
+                this.tuplesIterator = tuplesIterator;
+        }
+
+        @Override
+        public TupleLike getKey() {
+                return key;
+        }
+
+        @Override
+        public T getValue() {
+                return value;
+        }
+
+        @Override
+        public boolean isTerminated() {
+                return terminated;
+        }
+
+        @Override
+        public boolean move() {
+                if (!terminated && tuplesIterator.hasNext()) {
+                        var match = tuplesIterator.next();
+                        key = new OmitOutputViatraTupleLike(match);
+                        @SuppressWarnings("unchecked")
+                        var typedValue = (T) match.get(match.getSize() - 1);
+                        value = typedValue;
+                        return true;
+                }
+                terminated = true;
+                return false;
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraTupleLike.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/ViatraTupleLike.java
index 46c28434..76a3e40b 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraTupleLike.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/ViatraTupleLike.java
@@ -1,10 +1,10 @@
-package tools.refinery.store.query.viatra;
+package tools.refinery.store.query.viatra.internal.matcher;
 
 import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
 import tools.refinery.store.tuple.Tuple1;
 import tools.refinery.store.tuple.TupleLike;
 
-public record ViatraTupleLike(ITuple wrappedTuple) implements TupleLike {
+record ViatraTupleLike(ITuple wrappedTuple) implements TupleLike {
         @Override
         public int getSize() {
                 return wrappedTuple.getSize();
@@ -15,4 +15,9 @@ public record ViatraTupleLike(ITuple wrappedTuple) implements TupleLike {
                 var wrappedValue = (Tuple1) wrappedTuple.get(element);
                 return wrappedValue.value0();
         }
+
+        @Override
+        public String toString() {
+                return TupleLike.toString(this);
+        }
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/AssumptionEvaluator.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/AssumptionEvaluator.java
new file mode 100644
index 00000000..a80b0f90
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/AssumptionEvaluator.java
@@ -0,0 +1,16 @@
+package tools.refinery.store.query.viatra.internal.pquery;
+
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+import tools.refinery.store.query.term.Term;
+
+class AssumptionEvaluator extends TermEvaluator<Boolean> {
+        public AssumptionEvaluator(Term<Boolean> term) {
+                super(term);
+        }
+
+        @Override
+        public Object evaluateExpression(IValueProvider provider) {
+                var result = super.evaluateExpression(provider);
+                return result == null ? Boolean.FALSE : result;
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/DNF2PQuery.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/DNF2PQuery.java
deleted file mode 100644
index 60f1bcae..00000000
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/DNF2PQuery.java
+++ /dev/null
@@ -1,223 +0,0 @@
-package tools.refinery.store.query.viatra.internal.pquery;
-
-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
-import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
-import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
-import tools.refinery.store.query.DNF;
-import tools.refinery.store.query.DNFAnd;
-import tools.refinery.store.query.DNFUtils;
-import tools.refinery.store.query.Variable;
-import tools.refinery.store.query.atom.*;
-import tools.refinery.store.query.view.AnyRelationView;
-
-import java.util.*;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-public class DNF2PQuery {
-        private static final Object P_CONSTRAINT_LOCK = new Object();
-
-        private final Set<DNF> translating = new LinkedHashSet<>();
-
-        private final Map<DNF, RawPQuery> dnf2PQueryMap = new HashMap<>();
-
-        private final Map<AnyRelationView, RelationViewWrapper> view2WrapperMap = new LinkedHashMap<>();
-
-        private final Map<AnyRelationView, RawPQuery> view2EmbeddedMap = new HashMap<>();
-
-        private Function<DNF, QueryEvaluationHint> computeHint = dnf -> new QueryEvaluationHint(null,
-                        QueryEvaluationHint.BackendRequirement.UNSPECIFIED);
-
-        public void setComputeHint(Function<DNF, QueryEvaluationHint> computeHint) {
-                this.computeHint = computeHint;
-        }
-
-        public RawPQuery translate(DNF dnfQuery) {
-                if (translating.contains(dnfQuery)) {
-                        var path = translating.stream().map(DNF::name).collect(Collectors.joining(" -> "));
-                        throw new IllegalStateException("Circular reference %s -> %s detected".formatted(path,
-                                        dnfQuery.name()));
-                }
-                // We can't use computeIfAbsent here, because translating referenced queries calls this method in a reentrant
-                // way, which would cause a ConcurrentModificationException with computeIfAbsent.
-                var pQuery = dnf2PQueryMap.get(dnfQuery);
-                if (pQuery == null) {
-                        translating.add(dnfQuery);
-                        try {
-                                pQuery = doTranslate(dnfQuery);
-                                dnf2PQueryMap.put(dnfQuery, pQuery);
-                        } finally {
-                                translating.remove(dnfQuery);
-                        }
-                }
-                return pQuery;
-        }
-
-        public Map<AnyRelationView, IInputKey> getRelationViews() {
-                return Collections.unmodifiableMap(view2WrapperMap);
-        }
-
-        public RawPQuery getAlreadyTranslated(DNF dnfQuery) {
-                return dnf2PQueryMap.get(dnfQuery);
-        }
-
-        private RawPQuery doTranslate(DNF dnfQuery) {
-                var pQuery = new RawPQuery(dnfQuery.getUniqueName());
-                pQuery.setEvaluationHints(computeHint.apply(dnfQuery));
-
-                Map<Variable, PParameter> parameters = new HashMap<>();
-                for (Variable variable : dnfQuery.getParameters()) {
-                        parameters.put(variable, new PParameter(variable.getUniqueName()));
-                }
-
-                List<PParameter> parameterList = new ArrayList<>();
-                for (var param : dnfQuery.getParameters()) {
-                        parameterList.add(parameters.get(param));
-                }
-                pQuery.setParameters(parameterList);
-
-                for (var functionalDependency : dnfQuery.getFunctionalDependencies()) {
-                        var functionalDependencyAnnotation = new PAnnotation("FunctionalDependency");
-                        for (var forEachVariable : functionalDependency.forEach()) {
-                                functionalDependencyAnnotation.addAttribute("forEach", forEachVariable.getUniqueName());
-                        }
-                        for (var uniqueVariable : functionalDependency.unique()) {
-                                functionalDependencyAnnotation.addAttribute("unique", uniqueVariable.getUniqueName());
-                        }
-                        pQuery.addAnnotation(functionalDependencyAnnotation);
-                }
-
-                // The constructor of {@link org.eclipse.viatra.query.runtime.matchers.psystem.BasePConstraint} mutates
-                // global static state (<code>nextID</code>) without locking. Therefore, we need to synchronize before creating
-                // any query constraints to avoid a data race.
-                synchronized (P_CONSTRAINT_LOCK) {
-                        for (DNFAnd clause : dnfQuery.getClauses()) {
-                                PBody body = new PBody(pQuery);
-                                List<ExportedParameter> symbolicParameters = new ArrayList<>();
-                                for (var param : dnfQuery.getParameters()) {
-                                        PVariable pVar = body.getOrCreateVariableByName(param.getUniqueName());
-                                        symbolicParameters.add(new ExportedParameter(body, pVar, parameters.get(param)));
-                                }
-                                body.setSymbolicParameters(symbolicParameters);
-                                pQuery.addBody(body);
-                                for (DNFAtom constraint : clause.constraints()) {
-                                        translateDNFAtom(constraint, body);
-                                }
-                        }
-                }
-
-                return pQuery;
-        }
-
-        private void translateDNFAtom(DNFAtom constraint, PBody body) {
-                if (constraint instanceof EquivalenceAtom equivalenceAtom) {
-                        translateEquivalenceAtom(equivalenceAtom, body);
-                } else if (constraint instanceof RelationViewAtom relationViewAtom) {
-                        translateRelationViewAtom(relationViewAtom, body);
-                } else if (constraint instanceof DNFCallAtom callAtom) {
-                        translateCallAtom(callAtom, body);
-                } else if (constraint instanceof ConstantAtom constantAtom) {
-                        translateConstantAtom(constantAtom, body);
-                } else {
-                        throw new IllegalArgumentException("Unknown constraint: " + constraint.toString());
-                }
-        }
-
-        private void translateEquivalenceAtom(EquivalenceAtom equivalence, PBody body) {
-                PVariable varSource = body.getOrCreateVariableByName(equivalence.left().getUniqueName());
-                PVariable varTarget = body.getOrCreateVariableByName(equivalence.right().getUniqueName());
-                if (equivalence.positive()) {
-                        new Equality(body, varSource, varTarget);
-                } else {
-                        new Inequality(body, varSource, varTarget);
-                }
-        }
-
-        private void translateRelationViewAtom(RelationViewAtom relationViewAtom, PBody body) {
-                var substitution = translateSubstitution(relationViewAtom.getSubstitution(), body);
-                var polarity = relationViewAtom.getPolarity();
-                var relationView = relationViewAtom.getTarget();
-                if (polarity == CallPolarity.POSITIVE) {
-                        new TypeConstraint(body, substitution, wrapView(relationView));
-                } else {
-                        var embeddedPQuery = translateEmbeddedRelationViewPQuery(relationView);
-                        switch (polarity) {
-                        case TRANSITIVE -> new BinaryTransitiveClosure(body, substitution, embeddedPQuery);
-                        case NEGATIVE -> new NegativePatternCall(body, substitution, embeddedPQuery);
-                        default -> throw new IllegalArgumentException("Unknown polarity: " + polarity);
-                        }
-                }
-        }
-
-        private static Tuple translateSubstitution(List<Variable> substitution, PBody body) {
-                int arity = substitution.size();
-                Object[] variables = new Object[arity];
-                for (int i = 0; i < arity; i++) {
-                        var variable = substitution.get(i);
-                        variables[i] = body.getOrCreateVariableByName(variable.getUniqueName());
-                }
-                return Tuples.flatTupleOf(variables);
-        }
-
-        private RawPQuery translateEmbeddedRelationViewPQuery(AnyRelationView relationView) {
-                return view2EmbeddedMap.computeIfAbsent(relationView, this::doTranslateEmbeddedRelationViewPQuery);
-        }
-
-        private RawPQuery doTranslateEmbeddedRelationViewPQuery(AnyRelationView relationView) {
-                var embeddedPQuery = new RawPQuery(DNFUtils.generateUniqueName(relationView.name()), PVisibility.EMBEDDED);
-                var body = new PBody(embeddedPQuery);
-                int arity = relationView.arity();
-                var parameters = new ArrayList<PParameter>(arity);
-                var arguments = new Object[arity];
-                var symbolicParameters = new ArrayList<ExportedParameter>(arity);
-                for (int i = 0; i < arity; i++) {
-                        var parameterName = "p" + i;
-                        var parameter = new PParameter(parameterName);
-                        parameters.add(parameter);
-                        var variable = body.getOrCreateVariableByName(parameterName);
-                        arguments[i] = variable;
-                        symbolicParameters.add(new ExportedParameter(body, variable, parameter));
-                }
-                embeddedPQuery.setParameters(parameters);
-                body.setSymbolicParameters(symbolicParameters);
-                var argumentTuple = Tuples.flatTupleOf(arguments);
-                new TypeConstraint(body, argumentTuple, wrapView(relationView));
-                embeddedPQuery.addBody(body);
-                return embeddedPQuery;
-        }
-
-        private RelationViewWrapper wrapView(AnyRelationView relationView) {
-                return view2WrapperMap.computeIfAbsent(relationView, RelationViewWrapper::new);
-        }
-
-        private void translateCallAtom(DNFCallAtom callAtom, PBody body) {
-                var variablesTuple = translateSubstitution(callAtom.getSubstitution(), body);
-                var translatedReferred = translate(callAtom.getTarget());
-                var polarity = callAtom.getPolarity();
-                switch (polarity) {
-                case POSITIVE -> new PositivePatternCall(body, variablesTuple, translatedReferred);
-                case TRANSITIVE -> new BinaryTransitiveClosure(body, variablesTuple, translatedReferred);
-                case NEGATIVE -> new NegativePatternCall(body, variablesTuple, translatedReferred);
-                default -> throw new IllegalArgumentException("Unknown polarity: " + polarity);
-                }
-        }
-
-        private void translateConstantAtom(ConstantAtom constantAtom, PBody body) {
-                var variable = body.getOrCreateVariableByName(constantAtom.variable().getUniqueName());
-                new ConstantValue(body, variable, constantAtom.nodeId());
-        }
-}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
new file mode 100644
index 00000000..7afeb977
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
@@ -0,0 +1,256 @@
+package tools.refinery.store.query.viatra.internal.pquery;
+
+import org.eclipse.viatra.query.runtime.matchers.backend.IQueryBackendFactory;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.BoundAggregator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.*;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.DnfClause;
+import tools.refinery.store.query.literal.*;
+import tools.refinery.store.query.term.ConstantTerm;
+import tools.refinery.store.query.term.StatefulAggregator;
+import tools.refinery.store.query.term.StatelessAggregator;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.view.AnyRelationView;
+import tools.refinery.store.util.CycleDetectingMapper;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class Dnf2PQuery {
+        private static final Object P_CONSTRAINT_LOCK = new Object();
+        private final CycleDetectingMapper<Dnf, RawPQuery> mapper = new CycleDetectingMapper<>(Dnf::name,
+                        this::doTranslate);
+        private final QueryWrapperFactory wrapperFactory = new QueryWrapperFactory(this);
+        private final Map<Dnf, QueryEvaluationHint> hintOverrides = new LinkedHashMap<>();
+        private Function<Dnf, QueryEvaluationHint> computeHint = dnf -> new QueryEvaluationHint(null,
+                        (IQueryBackendFactory) null);
+
+        public void setComputeHint(Function<Dnf, QueryEvaluationHint> computeHint) {
+                this.computeHint = computeHint;
+        }
+
+        public RawPQuery translate(Dnf dnfQuery) {
+                return mapper.map(dnfQuery);
+        }
+
+        public Map<AnyRelationView, IInputKey> getRelationViews() {
+                return wrapperFactory.getRelationViews();
+        }
+
+        public void hint(Dnf dnf, QueryEvaluationHint hint) {
+                hintOverrides.compute(dnf, (ignoredKey, existingHint) ->
+                                existingHint == null ? hint : existingHint.overrideBy(hint));
+        }
+
+        private QueryEvaluationHint consumeHint(Dnf dnf) {
+                var defaultHint = computeHint.apply(dnf);
+                var existingHint = hintOverrides.remove(dnf);
+                return defaultHint.overrideBy(existingHint);
+        }
+
+        public void assertNoUnusedHints() {
+                if (hintOverrides.isEmpty()) {
+                        return;
+                }
+                var unusedHints = hintOverrides.keySet().stream().map(Dnf::name).collect(Collectors.joining(", "));
+                throw new IllegalStateException(
+                                "Unused query evaluation hints for %s. Hints must be set before a query is added to the engine"
+                                                .formatted(unusedHints));
+        }
+
+        private RawPQuery doTranslate(Dnf dnfQuery) {
+                var pQuery = new RawPQuery(dnfQuery.getUniqueName());
+                pQuery.setEvaluationHints(consumeHint(dnfQuery));
+
+                Map<Variable, PParameter> parameters = new HashMap<>();
+                for (Variable variable : dnfQuery.getParameters()) {
+                        parameters.put(variable, new PParameter(variable.getUniqueName()));
+                }
+
+                List<PParameter> parameterList = new ArrayList<>();
+                for (var param : dnfQuery.getParameters()) {
+                        parameterList.add(parameters.get(param));
+                }
+                pQuery.setParameters(parameterList);
+
+                for (var functionalDependency : dnfQuery.getFunctionalDependencies()) {
+                        var functionalDependencyAnnotation = new PAnnotation("FunctionalDependency");
+                        for (var forEachVariable : functionalDependency.forEach()) {
+                                functionalDependencyAnnotation.addAttribute("forEach", forEachVariable.getUniqueName());
+                        }
+                        for (var uniqueVariable : functionalDependency.unique()) {
+                                functionalDependencyAnnotation.addAttribute("unique", uniqueVariable.getUniqueName());
+                        }
+                        pQuery.addAnnotation(functionalDependencyAnnotation);
+                }
+
+                // The constructor of {@link org.eclipse.viatra.query.runtime.matchers.psystem.BasePConstraint} mutates
+                // global static state (<code>nextID</code>) without locking. Therefore, we need to synchronize before creating
+                // any query literals to avoid a data race.
+                synchronized (P_CONSTRAINT_LOCK) {
+                        for (DnfClause clause : dnfQuery.getClauses()) {
+                                PBody body = new PBody(pQuery);
+                                List<ExportedParameter> symbolicParameters = new ArrayList<>();
+                                for (var param : dnfQuery.getParameters()) {
+                                        PVariable pVar = body.getOrCreateVariableByName(param.getUniqueName());
+                                        symbolicParameters.add(new ExportedParameter(body, pVar, parameters.get(param)));
+                                }
+                                body.setSymbolicParameters(symbolicParameters);
+                                pQuery.addBody(body);
+                                for (Literal literal : clause.literals()) {
+                                        translateLiteral(literal, clause, body);
+                                }
+                        }
+                }
+
+                return pQuery;
+        }
+
+        private void translateLiteral(Literal literal, DnfClause clause, PBody body) {
+                if (literal instanceof EquivalenceLiteral equivalenceLiteral) {
+                        translateEquivalenceLiteral(equivalenceLiteral, body);
+                } else if (literal instanceof CallLiteral callLiteral) {
+                        translateCallLiteral(callLiteral, clause, body);
+                } else if (literal instanceof ConstantLiteral constantLiteral) {
+                        translateConstantLiteral(constantLiteral, body);
+                } else if (literal instanceof AssignLiteral<?> assignLiteral) {
+                        translateAssignLiteral(assignLiteral, body);
+                } else if (literal instanceof AssumeLiteral assumeLiteral) {
+                        translateAssumeLiteral(assumeLiteral, body);
+                } else if (literal instanceof CountLiteral countLiteral) {
+                        translateCountLiteral(countLiteral, clause, body);
+                } else if (literal instanceof AggregationLiteral<?, ?> aggregationLiteral) {
+                        translateAggregationLiteral(aggregationLiteral, clause, body);
+                } else {
+                        throw new IllegalArgumentException("Unknown literal: " + literal.toString());
+                }
+        }
+
+        private void translateEquivalenceLiteral(EquivalenceLiteral equivalenceLiteral, PBody body) {
+                PVariable varSource = body.getOrCreateVariableByName(equivalenceLiteral.left().getUniqueName());
+                PVariable varTarget = body.getOrCreateVariableByName(equivalenceLiteral.right().getUniqueName());
+                if (equivalenceLiteral.positive()) {
+                        new Equality(body, varSource, varTarget);
+                } else {
+                        new Inequality(body, varSource, varTarget);
+                }
+        }
+
+        private void translateCallLiteral(CallLiteral callLiteral, DnfClause clause, PBody body) {
+                var polarity = callLiteral.getPolarity();
+                switch (polarity) {
+                case POSITIVE -> {
+                        var substitution = translateSubstitution(callLiteral.getArguments(), body);
+                        var constraint = callLiteral.getTarget();
+                        if (constraint instanceof Dnf dnf) {
+                                var pattern = translate(dnf);
+                                new PositivePatternCall(body, substitution, pattern);
+                        } else if (constraint instanceof AnyRelationView relationView) {
+                                var inputKey = wrapperFactory.getInputKey(relationView);
+                                new TypeConstraint(body, substitution, inputKey);
+                        } else {
+                                throw new IllegalArgumentException("Unknown Constraint: " + constraint);
+                        }
+                }
+                case TRANSITIVE -> {
+                        var substitution = translateSubstitution(callLiteral.getArguments(), body);
+                        var constraint = callLiteral.getTarget();
+                        PQuery pattern;
+                        if (constraint instanceof Dnf dnf) {
+                                pattern = translate(dnf);
+                        } else if (constraint instanceof AnyRelationView relationView) {
+                                pattern = wrapperFactory.wrapRelationViewIdentityArguments(relationView);
+                        } else {
+                                throw new IllegalArgumentException("Unknown Constraint: " + constraint);
+                        }
+                        new BinaryTransitiveClosure(body, substitution, pattern);
+                }
+                case NEGATIVE -> {
+                        var wrappedCall = wrapperFactory.maybeWrapConstraint(callLiteral, clause);
+                        var substitution = translateSubstitution(wrappedCall.remappedArguments(), body);
+                        var pattern = wrappedCall.pattern();
+                        new NegativePatternCall(body, substitution, pattern);
+                }
+                default -> throw new IllegalArgumentException("Unknown polarity: " + polarity);
+                }
+        }
+
+        private static Tuple translateSubstitution(List<Variable> substitution, PBody body) {
+                int arity = substitution.size();
+                Object[] variables = new Object[arity];
+                for (int i = 0; i < arity; i++) {
+                        var variable = substitution.get(i);
+                        variables[i] = body.getOrCreateVariableByName(variable.getUniqueName());
+                }
+                return Tuples.flatTupleOf(variables);
+        }
+
+        private void translateConstantLiteral(ConstantLiteral constantLiteral, PBody body) {
+                var variable = body.getOrCreateVariableByName(constantLiteral.variable().getUniqueName());
+                new ConstantValue(body, variable, constantLiteral.nodeId());
+        }
+
+        private <T> void translateAssignLiteral(AssignLiteral<T> assignLiteral, PBody body) {
+                var variable = body.getOrCreateVariableByName(assignLiteral.variable().getUniqueName());
+                var term = assignLiteral.term();
+                if (term instanceof ConstantTerm<T> constantTerm) {
+                        new ConstantValue(body, variable, constantTerm.getValue());
+                } else {
+                        var evaluator = new TermEvaluator<>(term);
+                        new ExpressionEvaluation(body, evaluator, variable);
+                }
+        }
+
+        private void translateAssumeLiteral(AssumeLiteral assumeLiteral, PBody body) {
+                var evaluator = new AssumptionEvaluator(assumeLiteral.term());
+                new ExpressionEvaluation(body, evaluator, null);
+        }
+
+        private void translateCountLiteral(CountLiteral countLiteral, DnfClause clause, PBody body) {
+                var wrappedCall = wrapperFactory.maybeWrapConstraint(countLiteral, clause);
+                var substitution = translateSubstitution(wrappedCall.remappedArguments(), body);
+                var resultVariable = body.getOrCreateVariableByName(countLiteral.getResultVariable().getUniqueName());
+                new PatternMatchCounter(body, substitution, wrappedCall.pattern(), resultVariable);
+        }
+
+        private <R, T> void translateAggregationLiteral(AggregationLiteral<R, T> aggregationLiteral, DnfClause clause,
+                                                                                                        PBody body) {
+                var aggregator = aggregationLiteral.getAggregator();
+                IMultisetAggregationOperator<T, ?, R> aggregationOperator;
+                if (aggregator instanceof StatelessAggregator<R, T> statelessAggregator) {
+                        aggregationOperator = new StatelessMultisetAggregator<>(statelessAggregator);
+                } else if (aggregator instanceof StatefulAggregator<R, T> statefulAggregator) {
+                        aggregationOperator = new StatefulMultisetAggregator<>(statefulAggregator);
+                } else {
+                        throw new IllegalArgumentException("Unknown aggregator: " + aggregator);
+                }
+                var wrappedCall = wrapperFactory.maybeWrapConstraint(aggregationLiteral, clause);
+                var substitution = translateSubstitution(wrappedCall.remappedArguments(), body);
+                var inputVariable = body.getOrCreateVariableByName(aggregationLiteral.getInputVariable().getUniqueName());
+                var aggregatedColumn = substitution.invertIndex().get(inputVariable);
+                if (aggregatedColumn == null) {
+                        throw new IllegalStateException("Input variable %s not found in substitution %s".formatted(inputVariable,
+                                        substitution));
+                }
+                var boundAggregator = new BoundAggregator(aggregationOperator, aggregator.getInputType(),
+                                aggregator.getResultType());
+                var resultVariable = body.getOrCreateVariableByName(aggregationLiteral.getResultVariable().getUniqueName());
+                new AggregatorConstraint(boundAggregator, body, substitution, wrappedCall.pattern(), resultVariable,
+                                aggregatedColumn);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java
new file mode 100644
index 00000000..24ae5196
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java
@@ -0,0 +1,173 @@
+package tools.refinery.store.query.viatra.internal.pquery;
+
+import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.DnfClause;
+import tools.refinery.store.query.dnf.DnfUtils;
+import tools.refinery.store.query.literal.AbstractCallLiteral;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.view.AnyRelationView;
+import tools.refinery.store.query.view.RelationView;
+import tools.refinery.store.util.CycleDetectingMapper;
+
+import java.util.*;
+import java.util.function.ToIntFunction;
+
+class QueryWrapperFactory {
+        private final Dnf2PQuery dnf2PQuery;
+        private final Map<AnyRelationView, RelationViewWrapper> view2WrapperMap = new LinkedHashMap<>();
+        private final CycleDetectingMapper<RemappedConstraint, RawPQuery> wrapConstraint = new CycleDetectingMapper<>(
+                        RemappedConstraint::toString, this::doWrapConstraint);
+
+        QueryWrapperFactory(Dnf2PQuery dnf2PQuery) {
+                this.dnf2PQuery = dnf2PQuery;
+        }
+
+        public PQuery wrapRelationViewIdentityArguments(AnyRelationView relationView) {
+                var identity = new int[relationView.arity()];
+                for (int i = 0; i < identity.length; i++) {
+                        identity[i] = i;
+                }
+                return maybeWrapConstraint(relationView, identity);
+        }
+        public WrappedCall maybeWrapConstraint(AbstractCallLiteral callLiteral, DnfClause clause) {
+                var arguments = callLiteral.getArguments();
+                int arity = arguments.size();
+                var remappedParameters = new int[arity];
+                var boundVariables = clause.boundVariables();
+                var unboundVariableIndices = new HashMap<Variable, Integer>();
+                var appendVariable = new VariableAppender();
+                for (int i = 0; i < arity; i++) {
+                        var variable = arguments.get(i);
+                        if (boundVariables.contains(variable)) {
+                                // Do not join bound variable to make sure that the embedded pattern stays as general as possible.
+                                remappedParameters[i] = appendVariable.applyAsInt(variable);
+                        } else {
+                                remappedParameters[i] = unboundVariableIndices.computeIfAbsent(variable, appendVariable::applyAsInt);
+                        }
+                }
+                var pattern = maybeWrapConstraint(callLiteral.getTarget(), remappedParameters);
+                return new WrappedCall(pattern, appendVariable.getRemappedArguments());
+        }
+
+        private PQuery maybeWrapConstraint(Constraint constraint, int[] remappedParameters) {
+                if (remappedParameters.length != constraint.arity()) {
+                        throw new IllegalArgumentException("Constraint %s expected %d parameters, but got %d parameters".formatted(
+                                        constraint, constraint.arity(), remappedParameters.length));
+                }
+                if (constraint instanceof Dnf dnf && isIdentity(remappedParameters)) {
+                        return dnf2PQuery.translate(dnf);
+                }
+                return wrapConstraint.map(new RemappedConstraint(constraint, remappedParameters));
+        }
+
+        private static boolean isIdentity(int[] remappedParameters) {
+                for (int i = 0; i < remappedParameters.length; i++) {
+                        if (remappedParameters[i] != i) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+
+        private RawPQuery doWrapConstraint(RemappedConstraint remappedConstraint) {
+                var constraint = remappedConstraint.constraint();
+                var remappedParameters = remappedConstraint.remappedParameters();
+
+                var embeddedPQuery = new RawPQuery(DnfUtils.generateUniqueName(constraint.name()), PVisibility.EMBEDDED);
+                var body = new PBody(embeddedPQuery);
+                int arity = Arrays.stream(remappedParameters).max().orElse(-1) + 1;
+                var parameters = new ArrayList<PParameter>(arity);
+                var parameterVariables = new PVariable[arity];
+                var symbolicParameters = new ArrayList<ExportedParameter>(arity);
+                for (int i = 0; i < arity; i++) {
+                        var parameterName = "p" + i;
+                        var parameter = new PParameter(parameterName);
+                        parameters.add(parameter);
+                        var variable = body.getOrCreateVariableByName(parameterName);
+                        parameterVariables[i] = variable;
+                        symbolicParameters.add(new ExportedParameter(body, variable, parameter));
+                }
+                embeddedPQuery.setParameters(parameters);
+                body.setSymbolicParameters(symbolicParameters);
+
+                var arguments = new Object[remappedParameters.length];
+                for (int i = 0; i < remappedParameters.length; i++) {
+                        arguments[i] = parameterVariables[remappedParameters[i]];
+                }
+                var argumentTuple = Tuples.flatTupleOf(arguments);
+
+                if (constraint instanceof RelationView<?> relationView) {
+                        new TypeConstraint(body, argumentTuple, getInputKey(relationView));
+                } else if (constraint instanceof Dnf dnf) {
+                        var calledPQuery = dnf2PQuery.translate(dnf);
+                        new PositivePatternCall(body, argumentTuple, calledPQuery);
+                } else {
+                        throw new IllegalArgumentException("Unknown Constraint: " + constraint);
+                }
+
+                embeddedPQuery.addBody(body);
+                return embeddedPQuery;
+        }
+
+        public IInputKey getInputKey(AnyRelationView relationView) {
+                return view2WrapperMap.computeIfAbsent(relationView, RelationViewWrapper::new);
+        }
+
+        public Map<AnyRelationView, IInputKey> getRelationViews() {
+                return Collections.unmodifiableMap(view2WrapperMap);
+        }
+
+        public record WrappedCall(PQuery pattern, List<Variable> remappedArguments) {
+        }
+
+        private static class VariableAppender implements ToIntFunction<Variable> {
+                private final List<Variable> remappedArguments = new ArrayList<>();
+                private int nextIndex = 0;
+
+                @Override
+                public int applyAsInt(Variable variable) {
+                        remappedArguments.add(variable);
+                        int index = nextIndex;
+                        nextIndex++;
+                        return index;
+                }
+
+                public List<Variable> getRemappedArguments() {
+                        return remappedArguments;
+                }
+        }
+
+        private record RemappedConstraint(Constraint constraint, int[] remappedParameters) {
+                @Override
+                public boolean equals(Object o) {
+                        if (this == o) return true;
+                        if (o == null || getClass() != o.getClass()) return false;
+                        RemappedConstraint that = (RemappedConstraint) o;
+                        return constraint.equals(that.constraint) && Arrays.equals(remappedParameters, that.remappedParameters);
+                }
+
+                @Override
+                public int hashCode() {
+                        int result = Objects.hash(constraint);
+                        result = 31 * result + Arrays.hashCode(remappedParameters);
+                        return result;
+                }
+
+                @Override
+                public String toString() {
+                        return "RemappedConstraint{constraint=%s, remappedParameters=%s}".formatted(constraint,
+                                        Arrays.toString(remappedParameters));
+                }
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPQuery.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPQuery.java
index 71b74396..aad4ba3c 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPQuery.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPQuery.java
@@ -9,6 +9,7 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.queries.BasePQuery;
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
 import tools.refinery.store.query.viatra.internal.RelationalScope;
+import tools.refinery.store.query.viatra.internal.matcher.RawPatternMatcher;
 
 import java.util.LinkedHashSet;
 import java.util.List;
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPatternMatcher.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPatternMatcher.java
deleted file mode 100644
index e944e873..00000000
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPatternMatcher.java
+++ /dev/null
@@ -1,72 +0,0 @@
-package tools.refinery.store.query.viatra.internal.pquery;
-
-import org.eclipse.viatra.query.runtime.api.GenericPatternMatcher;
-import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification;
-import tools.refinery.store.query.ResultSet;
-import tools.refinery.store.query.viatra.ViatraTupleLike;
-import tools.refinery.store.tuple.Tuple;
-import tools.refinery.store.tuple.TupleLike;
-
-import java.util.Optional;
-import java.util.stream.Stream;
-
-public class RawPatternMatcher extends GenericPatternMatcher implements ResultSet {
-        protected final Object[] empty;
-
-        public RawPatternMatcher(GenericQuerySpecification<? extends GenericPatternMatcher> specification) {
-                super(specification);
-                empty = new Object[specification.getParameterNames().size()];
-        }
-
-        @Override
-        public boolean hasResult() {
-                return backend.hasMatch(empty);
-        }
-
-        @Override
-        public boolean hasResult(Tuple parameters) {
-                return backend.hasMatch(toParametersArray(parameters));
-        }
-
-        @Override
-        public Optional<TupleLike> oneResult() {
-                return backend.getOneArbitraryMatch(empty).map(ViatraTupleLike::new);
-        }
-
-        @Override
-        public Optional<TupleLike> oneResult(Tuple parameters) {
-                return backend.getOneArbitraryMatch(toParametersArray(parameters)).map(ViatraTupleLike::new);
-        }
-
-        @Override
-        public Stream<TupleLike> allResults() {
-                return backend.getAllMatches(empty).map(ViatraTupleLike::new);
-        }
-
-        @Override
-        public Stream<TupleLike> allResults(Tuple parameters) {
-                return backend.getAllMatches(toParametersArray(parameters)).map(ViatraTupleLike::new);
-        }
-
-        @Override
-        public int countResults() {
-                return backend.countMatches(empty);
-        }
-
-        @Override
-        public int countResults(Tuple parameters) {
-                return backend.countMatches(toParametersArray(parameters));
-        }
-
-        private Object[] toParametersArray(Tuple tuple) {
-                int size = tuple.getSize();
-                var array = new Object[tuple.getSize()];
-                for (int i = 0; i < size; i++) {
-                        var value = tuple.get(i);
-                        if (value >= 0) {
-                                array[i] = Tuple.of(value);
-                        }
-                }
-                return array;
-        }
-}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RelationViewWrapper.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RelationViewWrapper.java
index c442add8..48bf558d 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RelationViewWrapper.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RelationViewWrapper.java
@@ -27,4 +27,9 @@ public class RelationViewWrapper extends BaseInputKeyWrapper<AnyRelationView> {
         public boolean isEnumerable() {
                 return true;
         }
+
+        @Override
+        public String toString() {
+                return "RelationViewWrapper{wrappedKey=%s}".formatted(wrappedKey);
+        }
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/StatefulMultisetAggregator.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/StatefulMultisetAggregator.java
new file mode 100644
index 00000000..2798a252
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/StatefulMultisetAggregator.java
@@ -0,0 +1,60 @@
+package tools.refinery.store.query.viatra.internal.pquery;
+
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator;
+import tools.refinery.store.query.term.StatefulAggregate;
+import tools.refinery.store.query.term.StatefulAggregator;
+
+import java.util.stream.Stream;
+
+record StatefulMultisetAggregator<R, T>(StatefulAggregator<R, T> aggregator)
+        implements IMultisetAggregationOperator<T, StatefulAggregate<R, T>, R> {
+        @Override
+        public String getShortDescription() {
+                return getName();
+        }
+
+        @Override
+        public String getName() {
+                return aggregator.toString();
+        }
+
+        @Override
+        public StatefulAggregate<R, T> createNeutral() {
+                return aggregator.createEmptyAggregate();
+        }
+
+        @Override
+        public boolean isNeutral(StatefulAggregate<R, T> result) {
+                return result.isEmpty();
+        }
+
+        @Override
+        public StatefulAggregate<R, T> update(StatefulAggregate<R, T> oldResult, T updateValue, boolean isInsertion) {
+                if (isInsertion) {
+                        oldResult.add(updateValue);
+                } else {
+                        oldResult.remove(updateValue);
+                }
+                return oldResult;
+        }
+
+        @Override
+        public R getAggregate(StatefulAggregate<R, T> result) {
+                return result.getResult();
+        }
+
+        @Override
+        public R aggregateStream(Stream<T> stream) {
+                return aggregator.aggregateStream(stream);
+        }
+
+        @Override
+        public StatefulAggregate<R, T> clone(StatefulAggregate<R, T> original) {
+                return original.deepCopy();
+        }
+
+        @Override
+        public boolean contains(T value, StatefulAggregate<R, T> accumulator) {
+                return accumulator.contains(value);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/StatelessMultisetAggregator.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/StatelessMultisetAggregator.java
new file mode 100644
index 00000000..7cc71ee9
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/StatelessMultisetAggregator.java
@@ -0,0 +1,50 @@
+package tools.refinery.store.query.viatra.internal.pquery;
+
+import org.eclipse.viatra.query.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator;
+import tools.refinery.store.query.term.StatelessAggregator;
+
+import java.util.stream.Stream;
+
+record StatelessMultisetAggregator<R, T>(StatelessAggregator<R, T> aggregator)
+                implements IMultisetAggregationOperator<T, R, R> {
+        @Override
+        public String getShortDescription() {
+                return getName();
+        }
+
+        @Override
+        public String getName() {
+                return aggregator.toString();
+        }
+
+        @Override
+        public R createNeutral() {
+                return aggregator.getEmptyResult();
+        }
+
+        @Override
+        public boolean isNeutral(R result) {
+                return createNeutral().equals(result);
+        }
+
+        @Override
+        public R update(R oldResult, T updateValue, boolean isInsertion) {
+                return isInsertion ? aggregator.add(oldResult, updateValue) : aggregator.remove(oldResult, updateValue);
+        }
+
+        @Override
+        public R getAggregate(R result) {
+                return result;
+        }
+
+        @Override
+        public R clone(R original) {
+                // Aggregate result is immutable.
+                return original;
+        }
+
+        @Override
+        public R aggregateStream(Stream<T> stream) {
+                return aggregator.aggregateStream(stream);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/TermEvaluator.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/TermEvaluator.java
new file mode 100644
index 00000000..ab123c50
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/TermEvaluator.java
@@ -0,0 +1,32 @@
+package tools.refinery.store.query.viatra.internal.pquery;
+
+import org.eclipse.viatra.query.runtime.matchers.psystem.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+import tools.refinery.store.query.term.Term;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.stream.Collectors;
+
+class TermEvaluator<T> implements IExpressionEvaluator {
+        private final Term<T> term;
+
+        public TermEvaluator(Term<T> term) {
+                this.term = term;
+        }
+
+        @Override
+        public String getShortDescription() {
+                return term.toString();
+        }
+
+        @Override
+        public Iterable<String> getInputParameterNames() {
+                return term.getInputVariables().stream().map(Variable::getUniqueName).collect(Collectors.toUnmodifiableSet());
+        }
+
+        @Override
+        public Object evaluateExpression(IValueProvider provider) {
+                var valuation = new ValueProviderBasedValuation(provider);
+                return term.evaluate(valuation);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/ValueProviderBasedValuation.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/ValueProviderBasedValuation.java
new file mode 100644
index 00000000..30c2fce7
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/ValueProviderBasedValuation.java
@@ -0,0 +1,14 @@
+package tools.refinery.store.query.viatra.internal.pquery;
+
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.valuation.Valuation;
+
+public record ValueProviderBasedValuation(IValueProvider valueProvider) implements Valuation {
+        @Override
+        public <T> T getValue(DataVariable<T> variable) {
+                @SuppressWarnings("unchecked")
+                var value = (T) valueProvider.getValue(variable.getUniqueName());
+                return value;
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/ModelUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/ModelUpdateListener.java
index 8a467066..fc935aa6 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/ModelUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/ModelUpdateListener.java
@@ -22,10 +22,9 @@ public class ModelUpdateListener {
         }
 
         private <T> void registerView(ViatraModelQueryAdapterImpl adapter, RelationView<T> relationView) {
-                var listener = RelationViewUpdateListener.of(adapter, relationView);
                 var model = adapter.getModel();
                 var interpretation = model.getInterpretation(relationView.getSymbol());
-                interpretation.addListener(listener, true);
+                var listener = RelationViewUpdateListener.of(adapter, relationView, interpretation);
                 relationViewUpdateListeners.put(relationView, listener);
         }
 
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/RelationViewUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/RelationViewUpdateListener.java
index bf6b4197..5e5f60e3 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/RelationViewUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/RelationViewUpdateListener.java
@@ -4,6 +4,7 @@ import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
 import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextListener;
 import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.model.InterpretationListener;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
 import tools.refinery.store.query.view.RelationView;
@@ -14,18 +15,27 @@ import java.util.List;
 
 public abstract class RelationViewUpdateListener<T> implements InterpretationListener<T> {
         private final ViatraModelQueryAdapterImpl adapter;
+        private final Interpretation<T> interpretation;
         private final List<RelationViewFilter> filters = new ArrayList<>();
 
-        protected RelationViewUpdateListener(ViatraModelQueryAdapterImpl adapter) {
+        protected RelationViewUpdateListener(ViatraModelQueryAdapterImpl adapter, Interpretation<T> interpretation) {
                 this.adapter = adapter;
+                this.interpretation = interpretation;
         }
 
         public void addFilter(IInputKey inputKey, ITuple seed, IQueryRuntimeContextListener listener) {
+                if (filters.isEmpty()) {
+                        // First filter to be added, from now on we have to subscribe to model updates.
+                        interpretation.addListener(this, true);
+                }
                 filters.add(new RelationViewFilter(inputKey, seed, listener));
         }
 
         public void removeFilter(IInputKey inputKey, ITuple seed, IQueryRuntimeContextListener listener) {
-                filters.remove(new RelationViewFilter(inputKey, seed, listener));
+                if (filters.remove(new RelationViewFilter(inputKey, seed, listener)) && filters.isEmpty()) {
+                        // Last listener to be added, we don't have be subscribed to model updates anymore.
+                        interpretation.removeListener(this);
+                }
         }
 
         protected void processUpdate(Tuple tuple, boolean isInsertion) {
@@ -39,10 +49,12 @@ public abstract class RelationViewUpdateListener<T> implements InterpretationLis
         }
 
         public static <T> RelationViewUpdateListener<T> of(ViatraModelQueryAdapterImpl adapter,
-                                                                                                           RelationView<T> relationView) {
+                                                                                                           RelationView<T> relationView,
+                                                                                                           Interpretation<T> interpretation) {
                 if (relationView instanceof TuplePreservingRelationView<T> tuplePreservingRelationView) {
-                        return new TuplePreservingRelationViewUpdateListener<>(adapter, tuplePreservingRelationView);
+                        return new TuplePreservingRelationViewUpdateListener<>(adapter, tuplePreservingRelationView,
+                                        interpretation);
                 }
-                return new TupleChangingRelationViewUpdateListener<>(adapter, relationView);
+                return new TupleChangingRelationViewUpdateListener<>(adapter, relationView, interpretation);
         }
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TupleChangingRelationViewUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TupleChangingRelationViewUpdateListener.java
index 14142884..0f6ed3b3 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TupleChangingRelationViewUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TupleChangingRelationViewUpdateListener.java
@@ -1,6 +1,7 @@
 package tools.refinery.store.query.viatra.internal.update;
 
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
 import tools.refinery.store.query.view.RelationView;
 import tools.refinery.store.tuple.Tuple;
@@ -10,8 +11,9 @@ import java.util.Arrays;
 public class TupleChangingRelationViewUpdateListener<T> extends RelationViewUpdateListener<T> {
         private final RelationView<T> relationView;
 
-        TupleChangingRelationViewUpdateListener(ViatraModelQueryAdapterImpl adapter, RelationView<T> relationView) {
-        super(adapter);
+        TupleChangingRelationViewUpdateListener(ViatraModelQueryAdapterImpl adapter, RelationView<T> relationView,
+                                                                                        Interpretation<T> interpretation) {
+        super(adapter, interpretation);
         this.relationView = relationView;
         }
 
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TuplePreservingRelationViewUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TuplePreservingRelationViewUpdateListener.java
index 288e018a..91e9371b 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TuplePreservingRelationViewUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TuplePreservingRelationViewUpdateListener.java
@@ -1,6 +1,7 @@
 package tools.refinery.store.query.viatra.internal.update;
 
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
 import tools.refinery.store.query.view.TuplePreservingRelationView;
 import tools.refinery.store.tuple.Tuple;
@@ -9,8 +10,8 @@ public class TuplePreservingRelationViewUpdateListener<T> extends RelationViewUp
         private final TuplePreservingRelationView<T> view;
 
         TuplePreservingRelationViewUpdateListener(ViatraModelQueryAdapterImpl adapter,
-                                                                                          TuplePreservingRelationView<T> view) {
-        super(adapter);
+                                                                                          TuplePreservingRelationView<T> view, Interpretation<T> interpretation) {
+        super(adapter, interpretation);
         this.view = view;
         }
 
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/DiagonalQueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/DiagonalQueryTest.java
new file mode 100644
index 00000000..90229b73
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/DiagonalQueryTest.java
@@ -0,0 +1,471 @@
+package tools.refinery.store.query.viatra;
+
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.ModelQuery;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.viatra.tests.QueryEngineTest;
+import tools.refinery.store.query.view.FunctionalRelationView;
+import tools.refinery.store.query.view.KeyOnlyRelationView;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Map;
+import java.util.Optional;
+
+import static tools.refinery.store.query.literal.Literals.not;
+import static tools.refinery.store.query.term.int_.IntTerms.INT_SUM;
+import static tools.refinery.store.query.viatra.tests.QueryAssertions.assertNullableResults;
+import static tools.refinery.store.query.viatra.tests.QueryAssertions.assertResults;
+
+class DiagonalQueryTest {
+        @QueryEngineTest
+        void inputKeyNegationTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var symbol = new Symbol<>("symbol", 4, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+                var symbolView = new KeyOnlyRelationView<>(symbol);
+
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var query = Query.builder("Diagonal")
+                                .parameter(p1)
+                                .clause(
+                                                personView.call(p1),
+                                                not(symbolView.call(p1, p1, p2, p2))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, symbol)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var symbolInterpretation = model.getInterpretation(symbol);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                symbolInterpretation.put(Tuple.of(0, 0, 1, 1), true);
+                symbolInterpretation.put(Tuple.of(0, 0, 1, 2), true);
+                symbolInterpretation.put(Tuple.of(1, 1, 0, 1), true);
+                symbolInterpretation.put(Tuple.of(1, 2, 1, 1), true);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0), false,
+                                Tuple.of(1), true,
+                                Tuple.of(2), true,
+                                Tuple.of(3), false
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void subQueryNegationTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var symbol = new Symbol<>("symbol", 4, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+                var symbolView = new KeyOnlyRelationView<>(symbol);
+
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var p3 = Variable.of("p3");
+                var p4 = Variable.of("p4");
+                var subQuery = Dnf.builder("SubQuery")
+                                .parameters(p1, p2, p3, p4)
+                                .clause(
+                                                personView.call(p1),
+                                                symbolView.call(p1, p2, p3, p4)
+                                )
+                                .clause(
+                                                personView.call(p2),
+                                                symbolView.call(p1, p2, p3, p4)
+                                )
+                                .build();
+                var query = Query.builder("Diagonal")
+                                .parameter(p1)
+                                .clause(
+                                                personView.call(p1),
+                                                not(subQuery.call(p1, p1, p2, p2))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, symbol)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var symbolInterpretation = model.getInterpretation(symbol);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                symbolInterpretation.put(Tuple.of(0, 0, 1, 1), true);
+                symbolInterpretation.put(Tuple.of(0, 0, 1, 2), true);
+                symbolInterpretation.put(Tuple.of(1, 1, 0, 1), true);
+                symbolInterpretation.put(Tuple.of(1, 2, 1, 1), true);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0), false,
+                                Tuple.of(1), true,
+                                Tuple.of(2), true,
+                                Tuple.of(3), false
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void inputKeyCountTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var symbol = new Symbol<>("symbol", 4, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+                var symbolView = new KeyOnlyRelationView<>(symbol);
+
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var x = Variable.of("x", Integer.class);
+                var query = Query.builder("Diagonal")
+                                .parameter(p1)
+                                .output(x)
+                                .clause(
+                                                personView.call(p1),
+                                                x.assign(symbolView.count(p1, p1, p2, p2))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, symbol)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var symbolInterpretation = model.getInterpretation(symbol);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                symbolInterpretation.put(Tuple.of(0, 0, 1, 1), true);
+                symbolInterpretation.put(Tuple.of(0, 0, 2, 2), true);
+                symbolInterpretation.put(Tuple.of(0, 0, 1, 2), true);
+                symbolInterpretation.put(Tuple.of(1, 1, 0, 1), true);
+                symbolInterpretation.put(Tuple.of(1, 2, 1, 1), true);
+
+                queryEngine.flushChanges();
+                assertNullableResults(Map.of(
+                                Tuple.of(0), Optional.of(2),
+                                Tuple.of(1), Optional.of(0),
+                                Tuple.of(2), Optional.of(0),
+                                Tuple.of(3), Optional.empty()
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void subQueryCountTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var symbol = new Symbol<>("symbol", 4, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+                var symbolView = new KeyOnlyRelationView<>(symbol);
+
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var p3 = Variable.of("p3");
+                var p4 = Variable.of("p4");
+                var x = Variable.of("x", Integer.class);
+                var subQuery = Dnf.builder("SubQuery")
+                                .parameters(p1, p2, p3, p4)
+                                .clause(
+                                                personView.call(p1),
+                                                symbolView.call(p1, p2, p3, p4)
+                                )
+                                .clause(
+                                                personView.call(p2),
+                                                symbolView.call(p1, p2, p3, p4)
+                                )
+                                .build();
+                var query = Query.builder("Diagonal")
+                                .parameter(p1)
+                                .output(x)
+                                .clause(
+                                                personView.call(p1),
+                                                x.assign(subQuery.count(p1, p1, p2, p2))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, symbol)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var symbolInterpretation = model.getInterpretation(symbol);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                symbolInterpretation.put(Tuple.of(0, 0, 1, 1), true);
+                symbolInterpretation.put(Tuple.of(0, 0, 2, 2), true);
+                symbolInterpretation.put(Tuple.of(0, 0, 1, 2), true);
+                symbolInterpretation.put(Tuple.of(1, 1, 0, 1), true);
+                symbolInterpretation.put(Tuple.of(1, 2, 1, 1), true);
+
+                queryEngine.flushChanges();
+                assertNullableResults(Map.of(
+                                Tuple.of(0), Optional.of(2),
+                                Tuple.of(1), Optional.of(0),
+                                Tuple.of(2), Optional.of(0),
+                                Tuple.of(3), Optional.empty()
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void inputKeyAggregationTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var symbol = new Symbol<>("symbol", 4, Integer.class, null);
+                var personView = new KeyOnlyRelationView<>(person);
+                var symbolView = new FunctionalRelationView<>(symbol);
+
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var x = Variable.of("x", Integer.class);
+                var y = Variable.of("y", Integer.class);
+                var query = Query.builder("Diagonal")
+                                .parameter(p1)
+                                .output(x)
+                                .clause(
+                                                personView.call(p1),
+                                                x.assign(symbolView.aggregate(y, INT_SUM, p1, p1, p2, p2, y))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, symbol)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var symbolInterpretation = model.getInterpretation(symbol);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                symbolInterpretation.put(Tuple.of(0, 0, 1, 1), 1);
+                symbolInterpretation.put(Tuple.of(0, 0, 2, 2), 2);
+                symbolInterpretation.put(Tuple.of(0, 0, 1, 2), 10);
+                symbolInterpretation.put(Tuple.of(1, 1, 0, 1), 11);
+                symbolInterpretation.put(Tuple.of(1, 2, 1, 1), 12);
+
+                queryEngine.flushChanges();
+                assertNullableResults(Map.of(
+                                Tuple.of(0), Optional.of(3),
+                                Tuple.of(1), Optional.of(0),
+                                Tuple.of(2), Optional.of(0),
+                                Tuple.of(3), Optional.empty()
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void subQueryAggregationTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var symbol = new Symbol<>("symbol", 4, Integer.class, null);
+                var personView = new KeyOnlyRelationView<>(person);
+                var symbolView = new FunctionalRelationView<>(symbol);
+
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var p3 = Variable.of("p3");
+                var p4 = Variable.of("p4");
+                var x = Variable.of("x", Integer.class);
+                var y = Variable.of("y", Integer.class);
+                var z = Variable.of("z", Integer.class);
+                var subQuery = Dnf.builder("SubQuery")
+                                .parameters(p1, p2, p3, p4, x, y)
+                                .clause(
+                                                personView.call(p1),
+                                                symbolView.call(p1, p2, p3, p4, x),
+                                                y.assign(x)
+                                )
+                                .clause(
+                                                personView.call(p2),
+                                                symbolView.call(p1, p2, p3, p4, x),
+                                                y.assign(x)
+                                )
+                                .build();
+                var query = Query.builder("Diagonal")
+                                .parameter(p1)
+                                .output(x)
+                                .clause(
+                                                personView.call(p1),
+                                                x.assign(subQuery.aggregate(z, INT_SUM, p1, p1, p2, p2, z, z))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, symbol)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var symbolInterpretation = model.getInterpretation(symbol);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                symbolInterpretation.put(Tuple.of(0, 0, 1, 1), 1);
+                symbolInterpretation.put(Tuple.of(0, 0, 2, 2), 2);
+                symbolInterpretation.put(Tuple.of(0, 0, 1, 2), 10);
+                symbolInterpretation.put(Tuple.of(1, 1, 0, 1), 11);
+                symbolInterpretation.put(Tuple.of(1, 2, 1, 1), 12);
+
+                queryEngine.flushChanges();
+                assertNullableResults(Map.of(
+                                Tuple.of(0), Optional.of(3),
+                                Tuple.of(1), Optional.of(0),
+                                Tuple.of(2), Optional.of(0),
+                                Tuple.of(3), Optional.empty()
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void inputKeyTransitiveTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var symbol = new Symbol<>("symbol", 2, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+                var symbolView = new KeyOnlyRelationView<>(symbol);
+
+                var p1 = Variable.of("p1");
+                var query = Query.builder("Diagonal")
+                                .parameter(p1)
+                                .clause(
+                                                personView.call(p1),
+                                                symbolView.callTransitive(p1, p1)
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, symbol)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var symbolInterpretation = model.getInterpretation(symbol);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                symbolInterpretation.put(Tuple.of(0, 0), true);
+                symbolInterpretation.put(Tuple.of(0, 1), true);
+                symbolInterpretation.put(Tuple.of(1, 2), true);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), false,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void subQueryTransitiveTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var symbol = new Symbol<>("symbol", 2, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+                var symbolView = new KeyOnlyRelationView<>(symbol);
+
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var subQuery = Dnf.builder("SubQuery")
+                                .parameters(p1, p2)
+                                .clause(
+                                                personView.call(p1),
+                                                symbolView.call(p1, p2)
+                                )
+                                .clause(
+                                                personView.call(p2),
+                                                symbolView.call(p1, p2)
+                                )
+                                .build();
+                var query = Query.builder("Diagonal")
+                                .parameter(p1)
+                                .clause(
+                                                personView.call(p1),
+                                                subQuery.callTransitive(p1, p1)
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, symbol)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var symbolInterpretation = model.getInterpretation(symbol);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                symbolInterpretation.put(Tuple.of(0, 0), true);
+                symbolInterpretation.put(Tuple.of(0, 1), true);
+                symbolInterpretation.put(Tuple.of(1, 2), true);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), false,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), queryResultSet);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/FunctionalQueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/FunctionalQueryTest.java
new file mode 100644
index 00000000..fa2a008f
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/FunctionalQueryTest.java
@@ -0,0 +1,607 @@
+package tools.refinery.store.query.viatra;
+
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.ModelQuery;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.viatra.tests.QueryEngineTest;
+import tools.refinery.store.query.view.FilteredRelationView;
+import tools.refinery.store.query.view.FunctionalRelationView;
+import tools.refinery.store.query.view.KeyOnlyRelationView;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.Map;
+import java.util.Optional;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.nullValue;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static tools.refinery.store.query.literal.Literals.assume;
+import static tools.refinery.store.query.term.int_.IntTerms.*;
+import static tools.refinery.store.query.viatra.tests.QueryAssertions.assertNullableResults;
+import static tools.refinery.store.query.viatra.tests.QueryAssertions.assertResults;
+
+class FunctionalQueryTest {
+        @QueryEngineTest
+        void inputKeyTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var age = new Symbol<>("age", 1, Integer.class, null);
+                var personView = new KeyOnlyRelationView<>(person);
+                var ageView = new FunctionalRelationView<>(age);
+
+                var p1 = Variable.of("p1");
+                var x = Variable.of("x", Integer.class);
+                var query = Query.builder("InputKey")
+                                .parameter(p1)
+                                .output(x)
+                                .clause(
+                                                personView.call(p1),
+                                                ageView.call(p1, x)
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, age)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+
+                ageInterpretation.put(Tuple.of(0), 12);
+                ageInterpretation.put(Tuple.of(1), 24);
+                ageInterpretation.put(Tuple.of(2), 36);
+
+                queryEngine.flushChanges();
+                assertNullableResults(Map.of(
+                                Tuple.of(0), Optional.of(12),
+                                Tuple.of(1), Optional.of(24),
+                                Tuple.of(2), Optional.empty()
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void predicateTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var age = new Symbol<>("age", 1, Integer.class, null);
+                var personView = new KeyOnlyRelationView<>(person);
+                var ageView = new FunctionalRelationView<>(age);
+
+                var p1 = Variable.of("p1");
+                var x = Variable.of("x", Integer.class);
+                var subQuery = Dnf.builder("SubQuery")
+                                .parameters(p1, x)
+                                .clause(
+                                                personView.call(p1),
+                                                ageView.call(p1, x)
+                                )
+                                .build();
+                var query = Query.builder("Predicate")
+                                .parameter(p1)
+                                .output(x)
+                                .clause(
+                                                personView.call(p1),
+                                                subQuery.call(p1, x)
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, age)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+
+                ageInterpretation.put(Tuple.of(0), 12);
+                ageInterpretation.put(Tuple.of(1), 24);
+                ageInterpretation.put(Tuple.of(2), 36);
+
+                queryEngine.flushChanges();
+                assertNullableResults(Map.of(
+                                Tuple.of(0), Optional.of(12),
+                                Tuple.of(1), Optional.of(24),
+                                Tuple.of(2), Optional.empty()
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void computationTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var age = new Symbol<>("age", 1, Integer.class, null);
+                var personView = new KeyOnlyRelationView<>(person);
+                var ageView = new FunctionalRelationView<>(age);
+
+                var p1 = Variable.of("p1");
+                var x = Variable.of("x", Integer.class);
+                var y = Variable.of("y", Integer.class);
+                var query = Query.builder("Computation")
+                                .parameter(p1)
+                                .output(y)
+                                .clause(
+                                                personView.call(p1),
+                                                ageView.call(p1, x),
+                                                y.assign(mul(x, constant(7)))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, age)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+
+                ageInterpretation.put(Tuple.of(0), 12);
+                ageInterpretation.put(Tuple.of(1), 24);
+
+                queryEngine.flushChanges();
+                assertNullableResults(Map.of(
+                                Tuple.of(0), Optional.of(84),
+                                Tuple.of(1), Optional.of(168),
+                                Tuple.of(2), Optional.empty()
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void inputKeyCountTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
+                var personView = new KeyOnlyRelationView<>(person);
+                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var x = Variable.of("x", Integer.class);
+                var query = Query.builder("Count")
+                                .parameter(p1)
+                                .output(x)
+                                .clause(
+                                                personView.call(p1),
+                                                x.assign(friendMustView.count(p1, p2))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, friend)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var friendInterpretation = model.getInterpretation(friend);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                friendInterpretation.put(Tuple.of(0, 1), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 0), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
+
+                queryEngine.flushChanges();
+                assertNullableResults(Map.of(
+                                Tuple.of(0), Optional.of(1),
+                                Tuple.of(1), Optional.of(2),
+                                Tuple.of(2), Optional.of(0),
+                                Tuple.of(3), Optional.empty()
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void predicateCountTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
+                var personView = new KeyOnlyRelationView<>(person);
+                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var x = Variable.of("x", Integer.class);
+                var subQuery = Dnf.builder("SubQuery")
+                                .parameters(p1, p2)
+                                .clause(
+                                                personView.call(p1),
+                                                personView.call(p2),
+                                                friendMustView.call(p1, p2)
+                                )
+                                .build();
+                var query = Query.builder("Count")
+                                .parameter(p1)
+                                .output(x)
+                                .clause(
+                                                personView.call(p1),
+                                                x.assign(subQuery.count(p1, p2))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, friend)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var friendInterpretation = model.getInterpretation(friend);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                friendInterpretation.put(Tuple.of(0, 1), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 0), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
+
+                queryEngine.flushChanges();
+                assertNullableResults(Map.of(
+                                Tuple.of(0), Optional.of(1),
+                                Tuple.of(1), Optional.of(2),
+                                Tuple.of(2), Optional.of(0),
+                                Tuple.of(3), Optional.empty()
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void inputKeyAggregationTest(QueryEvaluationHint hint) {
+                var age = new Symbol<>("age", 1, Integer.class, null);
+                var ageView = new FunctionalRelationView<>(age);
+
+                var p1 = Variable.of("p1");
+                var x = Variable.of("x", Integer.class);
+                var y = Variable.of("y", Integer.class);
+                var query = Query.builder("Aggregate")
+                                .output(x)
+                                .clause(
+                                                x.assign(ageView.aggregate(y, INT_SUM, p1, y))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(age)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var ageInterpretation = model.getInterpretation(age);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                ageInterpretation.put(Tuple.of(0), 12);
+                ageInterpretation.put(Tuple.of(1), 24);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(Tuple.of(), 36), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void predicateAggregationTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var age = new Symbol<>("age", 1, Integer.class, null);
+                var personView = new KeyOnlyRelationView<>(person);
+                var ageView = new FunctionalRelationView<>(age);
+
+                var p1 = Variable.of("p1");
+                var x = Variable.of("x", Integer.class);
+                var y = Variable.of("y", Integer.class);
+                var subQuery = Dnf.builder("SubQuery")
+                                .parameters(p1, x)
+                                .clause(
+                                                personView.call(p1),
+                                                ageView.call(p1, x)
+                                )
+                                .build();
+                var query = Query.builder("Aggregate")
+                                .output(x)
+                                .clause(
+                                                x.assign(subQuery.aggregate(y, INT_SUM, p1, y))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, age)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+
+                ageInterpretation.put(Tuple.of(0), 12);
+                ageInterpretation.put(Tuple.of(1), 24);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(Tuple.of(), 36), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void extremeValueTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
+                var personView = new KeyOnlyRelationView<>(person);
+                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var x = Variable.of("x", Integer.class);
+                var y = Variable.of("y", Integer.class);
+                var subQuery = Dnf.builder("SubQuery")
+                                .parameters(p1, x)
+                                .clause(
+                                                personView.call(p1),
+                                                x.assign(friendMustView.count(p1, p2))
+                                )
+                                .build();
+                var minQuery = Query.builder("Min")
+                                .output(x)
+                                .clause(
+                                                x.assign(subQuery.aggregate(y, INT_MIN, p1, y))
+                                )
+                                .build();
+                var maxQuery = Query.builder("Max")
+                                .output(x)
+                                .clause(
+                                                x.assign(subQuery.aggregate(y, INT_MAX, p1, y))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, friend)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(minQuery, maxQuery)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var friendInterpretation = model.getInterpretation(friend);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var minResultSet = queryEngine.getResultSet(minQuery);
+                var maxResultSet = queryEngine.getResultSet(maxQuery);
+
+                assertResults(Map.of(Tuple.of(), Integer.MAX_VALUE), minResultSet);
+                assertResults(Map.of(Tuple.of(), Integer.MIN_VALUE), maxResultSet);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                friendInterpretation.put(Tuple.of(0, 1), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 0), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(Tuple.of(), 0), minResultSet);
+                assertResults(Map.of(Tuple.of(), 2), maxResultSet);
+
+                friendInterpretation.put(Tuple.of(2, 0), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(2, 1), TruthValue.TRUE);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(Tuple.of(), 1), minResultSet);
+                assertResults(Map.of(Tuple.of(), 2), maxResultSet);
+
+                friendInterpretation.put(Tuple.of(0, 1), TruthValue.FALSE);
+                friendInterpretation.put(Tuple.of(1, 0), TruthValue.FALSE);
+                friendInterpretation.put(Tuple.of(2, 0), TruthValue.FALSE);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(Tuple.of(), 0), minResultSet);
+                assertResults(Map.of(Tuple.of(), 1), maxResultSet);
+        }
+
+        @QueryEngineTest
+        void invalidComputationTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var age = new Symbol<>("age", 1, Integer.class, null);
+                var personView = new KeyOnlyRelationView<>(person);
+                var ageView = new FunctionalRelationView<>(age);
+
+                var p1 = Variable.of("p1");
+                var x = Variable.of("x", Integer.class);
+                var y = Variable.of("y", Integer.class);
+                var query = Query.builder("InvalidComputation")
+                                .parameter(p1)
+                                .output(y)
+                                .clause(
+                                                personView.call(p1),
+                                                ageView.call(p1, x),
+                                                y.assign(div(constant(120), x))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, age)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+
+                ageInterpretation.put(Tuple.of(0), 0);
+                ageInterpretation.put(Tuple.of(1), 30);
+
+                queryEngine.flushChanges();
+                assertNullableResults(Map.of(
+                                Tuple.of(0), Optional.empty(),
+                                Tuple.of(1), Optional.of(4),
+                                Tuple.of(2), Optional.empty()
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void invalidAssumeTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var age = new Symbol<>("age", 1, Integer.class, null);
+                var personView = new KeyOnlyRelationView<>(person);
+                var ageView = new FunctionalRelationView<>(age);
+
+                var p1 = Variable.of("p1");
+                var x = Variable.of("x", Integer.class);
+                var query = Query.builder("InvalidComputation")
+                                .parameter(p1)
+                                .clause(
+                                                personView.call(p1),
+                                                ageView.call(p1, x),
+                                                assume(lessEq(div(constant(120), x), constant(5)))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, age)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                ageInterpretation.put(Tuple.of(0), 0);
+                ageInterpretation.put(Tuple.of(1), 30);
+                ageInterpretation.put(Tuple.of(2), 20);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0), false,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), queryResultSet);
+        }
+
+        @QueryEngineTest
+        void notFunctionalTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var age = new Symbol<>("age", 1, Integer.class, null);
+                var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
+                var personView = new KeyOnlyRelationView<>(person);
+                var ageView = new FunctionalRelationView<>(age);
+                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var x = Variable.of("x", Integer.class);
+                var query = Query.builder("NotFunctional")
+                                .parameter(p1)
+                                .output(x)
+                                .clause(
+                                                personView.call(p1),
+                                                friendMustView.call(p1, p2),
+                                                ageView.call(p2, x)
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, age, friend)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .query(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var friendInterpretation = model.getInterpretation(friend);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                ageInterpretation.put(Tuple.of(0), 24);
+                ageInterpretation.put(Tuple.of(1), 30);
+                ageInterpretation.put(Tuple.of(2), 36);
+
+                friendInterpretation.put(Tuple.of(0, 1), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 0), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
+
+                queryEngine.flushChanges();
+                var invalidTuple = Tuple.of(1);
+                var cursor = queryResultSet.getAll();
+                assertAll(
+                                () -> assertThat("value for key 0", queryResultSet.get(Tuple.of(0)), is(30)),
+                                () -> assertThrows(IllegalStateException.class, () -> queryResultSet.get(invalidTuple),
+                                                "multiple values for key 1"),
+                                () -> assertThat("value for key 2", queryResultSet.get(Tuple.of(2)), is(nullValue())),
+                                () -> assertThat("value for key 3", queryResultSet.get(Tuple.of(3)), is(nullValue()))
+                );
+                if (hint.getQueryBackendRequirementType() != QueryEvaluationHint.BackendRequirement.DEFAULT_SEARCH) {
+                        // Local search doesn't support throwing an error on multiple function return values.
+                        assertThat("results size", queryResultSet.size(), is(2));
+                        assertThrows(IllegalStateException.class, () -> enumerateValues(cursor), "move cursor");
+                }
+        }
+
+        private static void enumerateValues(Cursor<?, ?> cursor) {
+                //noinspection StatementWithEmptyBody
+                while (cursor.move()) {
+                        // Nothing do, just let the cursor move through the result set.
+                }
+        }
+}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
index 6a37b54a..8a3f9d88 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
@@ -1,41 +1,47 @@
 package tools.refinery.store.query.viatra;
 
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.query.DNF;
 import tools.refinery.store.query.ModelQuery;
-import tools.refinery.store.query.Variable;
-import tools.refinery.store.query.atom.*;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.viatra.tests.QueryEngineTest;
 import tools.refinery.store.query.view.FilteredRelationView;
+import tools.refinery.store.query.view.FunctionalRelationView;
 import tools.refinery.store.query.view.KeyOnlyRelationView;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.tuple.Tuple;
-import tools.refinery.store.tuple.TupleLike;
 
-import java.util.HashSet;
-import java.util.Set;
-import java.util.stream.Stream;
+import java.util.Map;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static tools.refinery.store.query.literal.Literals.assume;
+import static tools.refinery.store.query.literal.Literals.not;
+import static tools.refinery.store.query.term.int_.IntTerms.constant;
+import static tools.refinery.store.query.term.int_.IntTerms.greaterEq;
+import static tools.refinery.store.query.viatra.tests.QueryAssertions.assertResults;
 
 class QueryTest {
-        @Test
-        void typeConstraintTest() {
+        @QueryEngineTest
+        void typeConstraintTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var asset = new Symbol<>("Asset", 1, Boolean.class, false);
                 var personView = new KeyOnlyRelationView<>(person);
 
-                var p1 = new Variable("p1");
-                var predicate = DNF.builder("TypeConstraint")
+                var p1 = Variable.of("p1");
+                var predicate = Query.builder("TypeConstraint")
                                 .parameters(p1)
-                                .clause(new RelationViewAtom(personView, p1))
+                                .clause(personView.call(p1))
                                 .build();
 
                 var store = ModelStore.builder()
                                 .symbols(person, asset)
                                 .with(ViatraModelQuery.ADAPTER)
-                                .queries(predicate)
+                                .defaultHint(hint)
+                                .query(predicate)
                                 .build();
 
                 var model = store.createEmptyModel();
@@ -51,31 +57,35 @@ class QueryTest {
                 assetInterpretation.put(Tuple.of(2), true);
 
                 queryEngine.flushChanges();
-                assertEquals(2, predicateResultSet.countResults());
-                compareMatchSets(predicateResultSet.allResults(), Set.of(Tuple.of(0), Tuple.of(1)));
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false
+                ), predicateResultSet);
         }
 
-        @Test
-        void relationConstraintTest() {
+        @QueryEngineTest
+        void relationConstraintTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 var personView = new KeyOnlyRelationView<>(person);
                 var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
 
-                var p1 = new Variable("p1");
-                var p2 = new Variable("p2");
-                var predicate = DNF.builder("RelationConstraint")
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var predicate = Query.builder("RelationConstraint")
                                 .parameters(p1, p2)
                                 .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(personView, p2),
-                                                new RelationViewAtom(friendMustView, p1, p2)
+                                                personView.call(p1),
+                                                personView.call(p2),
+                                                friendMustView.call(p1, p2)
                                 )
                                 .build();
 
                 var store = ModelStore.builder()
                                 .symbols(person, friend)
                                 .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
                                 .queries(predicate)
                                 .build();
 
@@ -85,8 +95,6 @@ class QueryTest {
                 var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
                 var predicateResultSet = queryEngine.getResultSet(predicate);
 
-                assertEquals(0, predicateResultSet.countResults());
-
                 personInterpretation.put(Tuple.of(0), true);
                 personInterpretation.put(Tuple.of(1), true);
                 personInterpretation.put(Tuple.of(2), true);
@@ -94,90 +102,39 @@ class QueryTest {
                 friendInterpretation.put(Tuple.of(0, 1), TruthValue.TRUE);
                 friendInterpretation.put(Tuple.of(1, 0), TruthValue.TRUE);
                 friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
-
-                assertEquals(0, predicateResultSet.countResults());
+                friendInterpretation.put(Tuple.of(1, 3), TruthValue.TRUE);
 
                 queryEngine.flushChanges();
-                assertEquals(3, predicateResultSet.countResults());
-                compareMatchSets(predicateResultSet.allResults(), Set.of(Tuple.of(0, 1), Tuple.of(1, 0), Tuple.of(1, 2)));
+                assertResults(Map.of(
+                                Tuple.of(0, 1), true,
+                                Tuple.of(1, 0), true,
+                                Tuple.of(1, 2), true,
+                                Tuple.of(2, 1), false
+                ), predicateResultSet);
         }
 
-        @Test
-        void andTest() {
+        @QueryEngineTest
+        void existTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 var personView = new KeyOnlyRelationView<>(person);
                 var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
 
-                var p1 = new Variable("p1");
-                var p2 = new Variable("p2");
-                var predicate = DNF.builder("RelationConstraint")
-                                .parameters(p1, p2)
-                                .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(personView, p2),
-                                                new RelationViewAtom(friendMustView, p1, p2),
-                                                new RelationViewAtom(friendMustView, p2, p1)
-                                )
-                                .build();
-
-                var store = ModelStore.builder()
-                                .symbols(person, friend)
-                                .with(ViatraModelQuery.ADAPTER)
-                                .queries(predicate)
-                                .build();
-
-                var model = store.createEmptyModel();
-                var personInterpretation = model.getInterpretation(person);
-                var friendInterpretation = model.getInterpretation(friend);
-                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
-                var predicateResultSet = queryEngine.getResultSet(predicate);
-
-                assertEquals(0, predicateResultSet.countResults());
-
-                personInterpretation.put(Tuple.of(0), true);
-                personInterpretation.put(Tuple.of(1), true);
-                personInterpretation.put(Tuple.of(2), true);
-
-                friendInterpretation.put(Tuple.of(0, 1), TruthValue.TRUE);
-                friendInterpretation.put(Tuple.of(0, 2), TruthValue.TRUE);
-
-                queryEngine.flushChanges();
-                assertEquals(0, predicateResultSet.countResults());
-
-                friendInterpretation.put(Tuple.of(1, 0), TruthValue.TRUE);
-                queryEngine.flushChanges();
-                assertEquals(2, predicateResultSet.countResults());
-                compareMatchSets(predicateResultSet.allResults(), Set.of(Tuple.of(0, 1), Tuple.of(1, 0)));
-
-                friendInterpretation.put(Tuple.of(2, 0), TruthValue.TRUE);
-                queryEngine.flushChanges();
-                assertEquals(4, predicateResultSet.countResults());
-                compareMatchSets(predicateResultSet.allResults(), Set.of(Tuple.of(0, 1), Tuple.of(1, 0), Tuple.of(0, 2),
-                                Tuple.of(2, 0)));
-        }
-
-        @Test
-        void existTest() {
-                var person = new Symbol<>("Person", 1, Boolean.class, false);
-                var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
-
-                var p1 = new Variable("p1");
-                var p2 = new Variable("p2");
-                var predicate = DNF.builder("RelationConstraint")
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var predicate = Query.builder("RelationConstraint")
                                 .parameters(p1)
                                 .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(personView, p2),
-                                                new RelationViewAtom(friendMustView, p1, p2)
+                                                personView.call(p1),
+                                                personView.call(p2),
+                                                friendMustView.call(p1, p2)
                                 )
                                 .build();
 
                 var store = ModelStore.builder()
                                 .symbols(person, friend)
                                 .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
                                 .queries(predicate)
                                 .build();
 
@@ -194,16 +151,19 @@ class QueryTest {
                 friendInterpretation.put(Tuple.of(0, 1), TruthValue.TRUE);
                 friendInterpretation.put(Tuple.of(1, 0), TruthValue.TRUE);
                 friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
-
-                assertEquals(0, predicateResultSet.countResults());
+                friendInterpretation.put(Tuple.of(3, 2), TruthValue.TRUE);
 
                 queryEngine.flushChanges();
-                assertEquals(2, predicateResultSet.countResults());
-                compareMatchSets(predicateResultSet.allResults(), Set.of(Tuple.of(0), Tuple.of(1)));
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), predicateResultSet);
         }
 
-        @Test
-        void orTest() {
+        @QueryEngineTest
+        void orTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var animal = new Symbol<>("Animal", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
@@ -211,25 +171,26 @@ class QueryTest {
                 var animalView = new KeyOnlyRelationView<>(animal);
                 var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
 
-                var p1 = new Variable("p1");
-                var p2 = new Variable("p2");
-                var predicate = DNF.builder("Or")
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var predicate = Query.builder("Or")
                                 .parameters(p1, p2)
                                 .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(personView, p2),
-                                                new RelationViewAtom(friendMustView, p1, p2)
+                                                personView.call(p1),
+                                                personView.call(p2),
+                                                friendMustView.call(p1, p2)
                                 )
                                 .clause(
-                                                new RelationViewAtom(animalView, p1),
-                                                new RelationViewAtom(animalView, p2),
-                                                new RelationViewAtom(friendMustView, p1, p2)
+                                                animalView.call(p1),
+                                                animalView.call(p2),
+                                                friendMustView.call(p1, p2)
                                 )
                                 .build();
 
                 var store = ModelStore.builder()
                                 .symbols(person, animal, friend)
                                 .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
                                 .queries(predicate)
                                 .build();
 
@@ -252,29 +213,35 @@ class QueryTest {
                 friendInterpretation.put(Tuple.of(3, 0), TruthValue.TRUE);
 
                 queryEngine.flushChanges();
-                assertEquals(2, predicateResultSet.countResults());
-                compareMatchSets(predicateResultSet.allResults(), Set.of(Tuple.of(0, 1), Tuple.of(2, 3)));
+                assertResults(Map.of(
+                                Tuple.of(0, 1), true,
+                                Tuple.of(0, 2), false,
+                                Tuple.of(2, 3), true,
+                                Tuple.of(3, 0), false,
+                                Tuple.of(3, 2), false
+                ), predicateResultSet);
         }
 
-        @Test
-        void equalityTest() {
+        @QueryEngineTest
+        void equalityTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var personView = new KeyOnlyRelationView<>(person);
 
-                var p1 = new Variable("p1");
-                var p2 = new Variable("p2");
-                var predicate = DNF.builder("Equality")
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var predicate = Query.builder("Equality")
                                 .parameters(p1, p2)
                                 .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(personView, p2),
-                                                new EquivalenceAtom(p1, p2)
+                                                personView.call(p1),
+                                                personView.call(p2),
+                                                p1.isEquivalent(p2)
                                 )
                                 .build();
 
                 var store = ModelStore.builder()
                                 .symbols(person)
                                 .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
                                 .queries(predicate)
                                 .build();
 
@@ -288,34 +255,40 @@ class QueryTest {
                 personInterpretation.put(Tuple.of(2), true);
 
                 queryEngine.flushChanges();
-                assertEquals(3, predicateResultSet.countResults());
-                compareMatchSets(predicateResultSet.allResults(), Set.of(Tuple.of(0, 0), Tuple.of(1, 1), Tuple.of(2, 2)));
+                assertResults(Map.of(
+                                Tuple.of(0, 0), true,
+                                Tuple.of(1, 1), true,
+                                Tuple.of(2, 2), true,
+                                Tuple.of(0, 1), false,
+                                Tuple.of(3, 3), false
+                ), predicateResultSet);
         }
 
-        @Test
-        void inequalityTest() {
+        @QueryEngineTest
+        void inequalityTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 var personView = new KeyOnlyRelationView<>(person);
                 var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
 
-                var p1 = new Variable("p1");
-                var p2 = new Variable("p2");
-                var p3 = new Variable("p3");
-                var predicate = DNF.builder("Inequality")
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var p3 = Variable.of("p3");
+                var predicate = Query.builder("Inequality")
                                 .parameters(p1, p2, p3)
                                 .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(personView, p2),
-                                                new RelationViewAtom(friendMustView, p1, p3),
-                                                new RelationViewAtom(friendMustView, p2, p3),
-                                                new EquivalenceAtom(false, p1, p2)
+                                                personView.call(p1),
+                                                personView.call(p2),
+                                                friendMustView.call(p1, p3),
+                                                friendMustView.call(p2, p3),
+                                                p1.notEquivalent(p2)
                                 )
                                 .build();
 
                 var store = ModelStore.builder()
                                 .symbols(person, friend)
                                 .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
                                 .queries(predicate)
                                 .build();
 
@@ -333,42 +306,46 @@ class QueryTest {
                 friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
 
                 queryEngine.flushChanges();
-                assertEquals(2, predicateResultSet.countResults());
-                compareMatchSets(predicateResultSet.allResults(), Set.of(Tuple.of(0, 1, 2), Tuple.of(1, 0, 2)));
+                assertResults(Map.of(
+                                Tuple.of(0, 1, 2), true,
+                                Tuple.of(1, 0, 2), true,
+                                Tuple.of(0, 0, 2), false
+                ), predicateResultSet);
         }
 
-        @Test
-        void patternCallTest() {
+        @QueryEngineTest
+        void patternCallTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 var personView = new KeyOnlyRelationView<>(person);
                 var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
 
-                var p1 = new Variable("p1");
-                var p2 = new Variable("p2");
-                var friendPredicate = DNF.builder("RelationConstraint")
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var friendPredicate = Dnf.builder("RelationConstraint")
                                 .parameters(p1, p2)
                                 .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(personView, p2),
-                                                new RelationViewAtom(friendMustView, p1, p2)
+                                                personView.call(p1),
+                                                personView.call(p2),
+                                                friendMustView.call(p1, p2)
                                 )
                                 .build();
 
-                var p3 = new Variable("p3");
-                var p4 = new Variable("p4");
-                var predicate = DNF.builder("PositivePatternCall")
+                var p3 = Variable.of("p3");
+                var p4 = Variable.of("p4");
+                var predicate = Query.builder("PositivePatternCall")
                                 .parameters(p3, p4)
                                 .clause(
-                                                new RelationViewAtom(personView, p3),
-                                                new RelationViewAtom(personView, p4),
-                                                new DNFCallAtom(friendPredicate, p3, p4)
+                                                personView.call(p3),
+                                                personView.call(p4),
+                                                friendPredicate.call(p3, p4)
                                 )
                                 .build();
 
                 var store = ModelStore.builder()
                                 .symbols(person, friend)
                                 .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
                                 .queries(predicate)
                                 .build();
 
@@ -387,30 +364,36 @@ class QueryTest {
                 friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
 
                 queryEngine.flushChanges();
-                assertEquals(3, predicateResultSet.countResults());
+                assertResults(Map.of(
+                                Tuple.of(0, 1), true,
+                                Tuple.of(1, 0), true,
+                                Tuple.of(1, 2), true,
+                                Tuple.of(2, 1), false
+                ), predicateResultSet);
         }
 
-        @Test
-        void negativeRelationViewTest() {
+        @QueryEngineTest
+        void negativeRelationViewTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 var personView = new KeyOnlyRelationView<>(person);
                 var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
 
-                var p1 = new Variable("p1");
-                var p2 = new Variable("p2");
-                var predicate = DNF.builder("NegativePatternCall")
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var predicate = Query.builder("NegativePatternCall")
                                 .parameters(p1, p2)
                                 .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(personView, p2),
-                                                new RelationViewAtom(false, friendMustView, p1, p2)
+                                                personView.call(p1),
+                                                personView.call(p2),
+                                                not(friendMustView.call(p1, p2))
                                 )
                                 .build();
 
                 var store = ModelStore.builder()
                                 .symbols(person, friend)
                                 .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
                                 .queries(predicate)
                                 .build();
 
@@ -429,41 +412,53 @@ class QueryTest {
                 friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
 
                 queryEngine.flushChanges();
-                assertEquals(6, predicateResultSet.countResults());
+                assertResults(Map.of(
+                                Tuple.of(0, 0), true,
+                                Tuple.of(0, 2), true,
+                                Tuple.of(1, 1), true,
+                                Tuple.of(2, 0), true,
+                                Tuple.of(2, 1), true,
+                                Tuple.of(2, 2), true,
+                                Tuple.of(0, 1), false,
+                                Tuple.of(1, 0), false,
+                                Tuple.of(1, 2), false,
+                                Tuple.of(0, 3), false
+                ), predicateResultSet);
         }
 
-        @Test
-        void negativePatternCallTest() {
+        @QueryEngineTest
+        void negativePatternCallTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 var personView = new KeyOnlyRelationView<>(person);
                 var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
 
-                var p1 = new Variable("p1");
-                var p2 = new Variable("p2");
-                var friendPredicate = DNF.builder("RelationConstraint")
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var friendPredicate = Dnf.builder("RelationConstraint")
                                 .parameters(p1, p2)
                                 .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(personView, p2),
-                                                new RelationViewAtom(friendMustView, p1, p2)
+                                                personView.call(p1),
+                                                personView.call(p2),
+                                                friendMustView.call(p1, p2)
                                 )
                                 .build();
 
-                var p3 = new Variable("p3");
-                var p4 = new Variable("p4");
-                var predicate = DNF.builder("NegativePatternCall")
+                var p3 = Variable.of("p3");
+                var p4 = Variable.of("p4");
+                var predicate = Query.builder("NegativePatternCall")
                                 .parameters(p3, p4)
                                 .clause(
-                                                new RelationViewAtom(personView, p3),
-                                                new RelationViewAtom(personView, p4),
-                                                new DNFCallAtom(false, friendPredicate, p3, p4)
+                                                personView.call(p3),
+                                                personView.call(p4),
+                                                not(friendPredicate.call(p3, p4))
                                 )
                                 .build();
 
                 var store = ModelStore.builder()
                                 .symbols(person, friend)
                                 .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
                                 .queries(predicate)
                                 .build();
 
@@ -482,30 +477,42 @@ class QueryTest {
                 friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
 
                 queryEngine.flushChanges();
-                assertEquals(6, predicateResultSet.countResults());
+                assertResults(Map.of(
+                                Tuple.of(0, 0), true,
+                                Tuple.of(0, 2), true,
+                                Tuple.of(1, 1), true,
+                                Tuple.of(2, 0), true,
+                                Tuple.of(2, 1), true,
+                                Tuple.of(2, 2), true,
+                                Tuple.of(0, 1), false,
+                                Tuple.of(1, 0), false,
+                                Tuple.of(1, 2), false,
+                                Tuple.of(0, 3), false
+                ), predicateResultSet);
         }
 
-        @Test
-        void negativeRelationViewWithQuantificationTest() {
+        @QueryEngineTest
+        void negativeRelationViewWithQuantificationTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 var personView = new KeyOnlyRelationView<>(person);
                 var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
 
-                var p1 = new Variable("p1");
-                var p2 = new Variable("p2");
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
 
-                var predicate = DNF.builder("Count")
+                var predicate = Query.builder("Count")
                                 .parameters(p1)
                                 .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(false, friendMustView, p1, p2)
+                                                personView.call(p1),
+                                                not(friendMustView.call(p1, p2))
                                 )
                                 .build();
 
                 var store = ModelStore.builder()
                                 .symbols(person, friend)
                                 .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
                                 .queries(predicate)
                                 .build();
 
@@ -523,39 +530,45 @@ class QueryTest {
                 friendInterpretation.put(Tuple.of(0, 2), TruthValue.TRUE);
 
                 queryEngine.flushChanges();
-                assertEquals(2, predicateResultSet.countResults());
+                assertResults(Map.of(
+                                Tuple.of(0), false,
+                                Tuple.of(1), true,
+                                Tuple.of(2), true,
+                                Tuple.of(3), false
+                ), predicateResultSet);
         }
 
-        @Test
-        void negativeWithQuantificationTest() {
+        @QueryEngineTest
+        void negativeWithQuantificationTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 var personView = new KeyOnlyRelationView<>(person);
                 var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
 
-                var p1 = new Variable("p1");
-                var p2 = new Variable("p2");
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
 
-                var called = DNF.builder("Called")
+                var called = Dnf.builder("Called")
                                 .parameters(p1, p2)
                                 .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(personView, p2),
-                                                new RelationViewAtom(friendMustView, p1, p2)
+                                                personView.call(p1),
+                                                personView.call(p2),
+                                                friendMustView.call(p1, p2)
                                 )
                                 .build();
 
-                var predicate = DNF.builder("Count")
+                var predicate = Query.builder("Count")
                                 .parameters(p1)
                                 .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new DNFCallAtom(false, called, p1, p2)
+                                                personView.call(p1),
+                                                not(called.call(p1, p2))
                                 )
                                 .build();
 
                 var store = ModelStore.builder()
                                 .symbols(person, friend)
                                 .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
                                 .queries(predicate)
                                 .build();
 
@@ -573,30 +586,36 @@ class QueryTest {
                 friendInterpretation.put(Tuple.of(0, 2), TruthValue.TRUE);
 
                 queryEngine.flushChanges();
-                assertEquals(2, predicateResultSet.countResults());
+                assertResults(Map.of(
+                                Tuple.of(0), false,
+                                Tuple.of(1), true,
+                                Tuple.of(2), true,
+                                Tuple.of(3), false
+                ), predicateResultSet);
         }
 
-        @Test
-        void transitiveRelationViewTest() {
+        @QueryEngineTest
+        void transitiveRelationViewTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 var personView = new KeyOnlyRelationView<>(person);
                 var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
 
-                var p1 = new Variable("p1");
-                var p2 = new Variable("p2");
-                var predicate = DNF.builder("TransitivePatternCall")
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var predicate = Query.builder("TransitivePatternCall")
                                 .parameters(p1, p2)
                                 .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(personView, p2),
-                                                new RelationViewAtom(CallPolarity.TRANSITIVE, friendMustView, p1, p2)
+                                                personView.call(p1),
+                                                personView.call(p2),
+                                                friendMustView.callTransitive(p1, p2)
                                 )
                                 .build();
 
                 var store = ModelStore.builder()
                                 .symbols(person, friend)
                                 .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
                                 .queries(predicate)
                                 .build();
 
@@ -614,41 +633,53 @@ class QueryTest {
                 friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
 
                 queryEngine.flushChanges();
-                assertEquals(3, predicateResultSet.countResults());
+                assertResults(Map.of(
+                                Tuple.of(0, 0), false,
+                                Tuple.of(0, 1), true,
+                                Tuple.of(0, 2), true,
+                                Tuple.of(1, 0), false,
+                                Tuple.of(1, 1), false,
+                                Tuple.of(1, 2), true,
+                                Tuple.of(2, 0), false,
+                                Tuple.of(2, 1), false,
+                                Tuple.of(2, 2), false,
+                                Tuple.of(2, 3), false
+                ), predicateResultSet);
         }
 
-        @Test
-        void transitivePatternCallTest() {
+        @QueryEngineTest
+        void transitivePatternCallTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
                 var personView = new KeyOnlyRelationView<>(person);
                 var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
 
-                var p1 = new Variable("p1");
-                var p2 = new Variable("p2");
-                var friendPredicate = DNF.builder("RelationConstraint")
+                var p1 = Variable.of("p1");
+                var p2 = Variable.of("p2");
+                var friendPredicate = Dnf.builder("RelationConstraint")
                                 .parameters(p1, p2)
                                 .clause(
-                                                new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(personView, p2),
-                                                new RelationViewAtom(friendMustView, p1, p2)
+                                                personView.call(p1),
+                                                personView.call(p2),
+                                                friendMustView.call(p1, p2)
                                 )
                                 .build();
 
-                var p3 = new Variable("p3");
-                var p4 = new Variable("p4");
-                var predicate = DNF.builder("TransitivePatternCall")
+                var p3 = Variable.of("p3");
+                var p4 = Variable.of("p4");
+                var predicate = Query.builder("TransitivePatternCall")
                                 .parameters(p3, p4)
                                 .clause(
-                                                new RelationViewAtom(personView, p3),
-                                                new RelationViewAtom(personView, p4),
-                                                new DNFCallAtom(CallPolarity.TRANSITIVE, friendPredicate, p3, p4)
+                                                personView.call(p3),
+                                                personView.call(p4),
+                                                friendPredicate.callTransitive(p3, p4)
                                 )
                                 .build();
 
                 var store = ModelStore.builder()
                                 .symbols(person, friend)
                                 .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
                                 .queries(predicate)
                                 .build();
 
@@ -666,16 +697,101 @@ class QueryTest {
                 friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
 
                 queryEngine.flushChanges();
-                assertEquals(3, predicateResultSet.countResults());
+                assertResults(Map.of(
+                                Tuple.of(0, 0), false,
+                                Tuple.of(0, 1), true,
+                                Tuple.of(0, 2), true,
+                                Tuple.of(1, 0), false,
+                                Tuple.of(1, 1), false,
+                                Tuple.of(1, 2), true,
+                                Tuple.of(2, 0), false,
+                                Tuple.of(2, 1), false,
+                                Tuple.of(2, 2), false,
+                                Tuple.of(2, 3), false
+                ), predicateResultSet);
+        }
+
+        @QueryEngineTest
+        void assumeTest(QueryEvaluationHint hint) {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var age = new Symbol<>("age", 1, Integer.class, null);
+                var personView = new KeyOnlyRelationView<>(person);
+                var ageView = new FunctionalRelationView<>(age);
+
+                var p1 = Variable.of("p1");
+                var x = Variable.of("x", Integer.class);
+                var query = Query.builder("Constraint")
+                                .parameter(p1)
+                                .clause(
+                                                personView.call(p1),
+                                                ageView.call(p1, x),
+                                                assume(greaterEq(x, constant(18)))
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, age)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(hint)
+                                .queries(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+
+                ageInterpretation.put(Tuple.of(0), 12);
+                ageInterpretation.put(Tuple.of(1), 24);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0), false,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false
+                ), queryResultSet);
+        }
+
+        @Test
+        void alwaysFalseTest() {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+
+                var p1 = Variable.of("p1");
+                var predicate = Query.builder("AlwaysFalse").parameters(p1).build();
+
+                var store = ModelStore.builder()
+                                .symbols(person)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .queries(predicate)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var predicateResultSet = queryEngine.getResultSet(predicate);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(), predicateResultSet);
         }
 
-        static void compareMatchSets(Stream<TupleLike> matchSet, Set<Tuple> expected) {
-                Set<Tuple> translatedMatchSet = new HashSet<>();
-                var iterator = matchSet.iterator();
-                while (iterator.hasNext()) {
-                        var element = iterator.next();
-                        translatedMatchSet.add(element.toTuple());
-                }
-                assertEquals(expected, translatedMatchSet);
+        @Test
+        void alwaysTrueTest() {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+
+                var p1 = Variable.of("p1");
+                var predicate = Query.builder("AlwaysTrue").parameters(p1).clause().build();
+
+                var storeBuilder = ModelStore.builder().symbols(person);
+                var queryBuilder = storeBuilder.with(ViatraModelQuery.ADAPTER);
+
+                assertThrows(IllegalArgumentException.class, () -> queryBuilder.queries(predicate));
         }
 }
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java
index 98995339..abd49341 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java
@@ -1,28 +1,162 @@
 package tools.refinery.store.query.viatra;
 
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.query.DNF;
 import tools.refinery.store.query.ModelQuery;
-import tools.refinery.store.query.Variable;
-import tools.refinery.store.query.atom.RelationViewAtom;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.view.FilteredRelationView;
+import tools.refinery.store.query.view.FunctionalRelationView;
 import tools.refinery.store.query.view.KeyOnlyRelationView;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
 
-import static org.junit.jupiter.api.Assertions.*;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static tools.refinery.store.query.viatra.tests.QueryAssertions.assertNullableResults;
+import static tools.refinery.store.query.viatra.tests.QueryAssertions.assertResults;
 
 class QueryTransactionTest {
         @Test
         void flushTest() {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+
+                var p1 = Variable.of("p1");
+                var predicate = Query.builder("TypeConstraint")
+                                .parameters(p1)
+                                .clause(personView.call(p1))
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .queries(predicate)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var predicateResultSet = queryEngine.getResultSet(predicate);
+
+                assertResults(Map.of(
+                                Tuple.of(0), false,
+                                Tuple.of(1), false,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), predicateResultSet);
+                assertFalse(queryEngine.hasPendingChanges());
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+
+                assertResults(Map.of(
+                                Tuple.of(0), false,
+                                Tuple.of(1), false,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), predicateResultSet);
+                assertTrue(queryEngine.hasPendingChanges());
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), predicateResultSet);
+                assertFalse(queryEngine.hasPendingChanges());
+
+                personInterpretation.put(Tuple.of(1), false);
+                personInterpretation.put(Tuple.of(2), true);
+
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), predicateResultSet);
+                assertTrue(queryEngine.hasPendingChanges());
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), false,
+                                Tuple.of(2), true,
+                                Tuple.of(3), false
+                ), predicateResultSet);
+                assertFalse(queryEngine.hasPendingChanges());
+        }
+
+        @Test
+        void localSearchTest() {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+
+                var p1 = Variable.of("p1");
+                var predicate = Query.builder("TypeConstraint")
+                                .parameters(p1)
+                                .clause(personView.call(p1))
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .defaultHint(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.DEFAULT_SEARCH))
+                                .queries(predicate)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var predicateResultSet = queryEngine.getResultSet(predicate);
+
+                assertResults(Map.of(
+                                Tuple.of(0), false,
+                                Tuple.of(1), false,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), predicateResultSet);
+                assertFalse(queryEngine.hasPendingChanges());
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), predicateResultSet);
+                assertFalse(queryEngine.hasPendingChanges());
+
+                personInterpretation.put(Tuple.of(1), false);
+                personInterpretation.put(Tuple.of(2), true);
+
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), false,
+                                Tuple.of(2), true,
+                                Tuple.of(3), false
+                ), predicateResultSet);
+                assertFalse(queryEngine.hasPendingChanges());
+        }
+
+        @Test
+        void unrelatedChangesTest() {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var asset = new Symbol<>("Asset", 1, Boolean.class, false);
                 var personView = new KeyOnlyRelationView<>(person);
 
-                var p1 = new Variable("p1");
-                var predicate = DNF.builder("TypeConstraint")
+                var p1 = Variable.of("p1");
+                var predicate = Query.builder("TypeConstraint")
                                 .parameters(p1)
-                                .clause(new RelationViewAtom(personView, p1))
+                                .clause(personView.call(p1))
                                 .build();
 
                 var store = ModelStore.builder()
@@ -37,7 +171,6 @@ class QueryTransactionTest {
                 var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
                 var predicateResultSet = queryEngine.getResultSet(predicate);
 
-                assertEquals(0, predicateResultSet.countResults());
                 assertFalse(queryEngine.hasPendingChanges());
 
                 personInterpretation.put(Tuple.of(0), true);
@@ -46,19 +179,245 @@ class QueryTransactionTest {
                 assetInterpretation.put(Tuple.of(1), true);
                 assetInterpretation.put(Tuple.of(2), true);
 
-                assertEquals(0, predicateResultSet.countResults());
+                assertResults(Map.of(
+                                Tuple.of(0), false,
+                                Tuple.of(1), false,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false,
+                                Tuple.of(4), false
+                ), predicateResultSet);
                 assertTrue(queryEngine.hasPendingChanges());
 
                 queryEngine.flushChanges();
-                assertEquals(2, predicateResultSet.countResults());
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false,
+                                Tuple.of(4), false
+                ), predicateResultSet);
                 assertFalse(queryEngine.hasPendingChanges());
 
-                personInterpretation.put(Tuple.of(4), true);
-                assertEquals(2, predicateResultSet.countResults());
-                assertTrue(queryEngine.hasPendingChanges());
+                assetInterpretation.put(Tuple.of(3), true);
+                assertFalse(queryEngine.hasPendingChanges());
+
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false,
+                                Tuple.of(4), false
+                ), predicateResultSet);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false,
+                                Tuple.of(4), false
+                ), predicateResultSet);
+                assertFalse(queryEngine.hasPendingChanges());
+        }
+
+        @Test
+        void tupleChangingChangeTest() {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var age = new Symbol<>("age", 1, Integer.class, null);
+                var personView = new KeyOnlyRelationView<>(person);
+                var ageView = new FunctionalRelationView<>(age);
+
+                var p1 = Variable.of("p1");
+                var x = Variable.of("x", Integer.class);
+                var query = Query.builder()
+                                .parameter(p1)
+                                .output(x)
+                                .clause(
+                                                personView.call(p1),
+                                                ageView.call(p1, x)
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, age)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .query(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+
+                ageInterpretation.put(Tuple.of(0), 24);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(Tuple.of(0), 24), queryResultSet);
+
+                ageInterpretation.put(Tuple.of(0), 25);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(Tuple.of(0), 25), queryResultSet);
+
+                ageInterpretation.put(Tuple.of(0), null);
 
                 queryEngine.flushChanges();
-                assertEquals(3, predicateResultSet.countResults());
+                assertNullableResults(Map.of(Tuple.of(0), Optional.empty()), queryResultSet);
+        }
+
+        @Test
+        void tuplePreservingUnchangedTest() {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var age = new Symbol<>("age", 1, Integer.class, null);
+                var personView = new KeyOnlyRelationView<>(person);
+                var adultView = new FilteredRelationView<>(age, "adult", n -> n != null && n >= 18);
+
+                var p1 = Variable.of("p1");
+                var x = Variable.of("x", Integer.class);
+                var query = Query.builder()
+                                .parameter(p1)
+                                .clause(
+                                                personView.call(p1),
+                                                adultView.call(p1)
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, age)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .query(query)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+
+                ageInterpretation.put(Tuple.of(0), 24);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(Tuple.of(0), true), queryResultSet);
+
+                ageInterpretation.put(Tuple.of(0), 25);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(Tuple.of(0), true), queryResultSet);
+
+                ageInterpretation.put(Tuple.of(0), 17);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(Tuple.of(0), false), queryResultSet);
+        }
+
+        @Disabled("TODO Fix DiffCursor")
+        @Test
+        void commitAfterFlushTest() {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+
+                var p1 = Variable.of("p1");
+                var predicate = Query.builder("TypeConstraint")
+                                .parameters(p1)
+                                .clause(personView.call(p1))
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .queries(predicate)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var predicateResultSet = queryEngine.getResultSet(predicate);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), predicateResultSet);
+
+                var state1 = model.commit();
+
+                personInterpretation.put(Tuple.of(1), false);
+                personInterpretation.put(Tuple.of(2), true);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), false,
+                                Tuple.of(2), true,
+                                Tuple.of(3), false
+                ), predicateResultSet);
+
+                model.restore(state1);
+
+                assertFalse(queryEngine.hasPendingChanges());
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), predicateResultSet);
+        }
+
+        @Disabled("TODO Fix DiffCursor")
+        @Test
+        void commitWithoutFlushTest() {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+
+                var p1 = Variable.of("p1");
+                var predicate = Query.builder("TypeConstraint")
+                                .parameters(p1)
+                                .clause(personView.call(p1))
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .queries(predicate)
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var predicateResultSet = queryEngine.getResultSet(predicate);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+
+                assertResults(Map.of(), predicateResultSet);
+                assertTrue(queryEngine.hasPendingChanges());
+
+                var state1 = model.commit();
+
+                personInterpretation.put(Tuple.of(1), false);
+                personInterpretation.put(Tuple.of(2), true);
+
+                assertResults(Map.of(), predicateResultSet);
+                assertTrue(queryEngine.hasPendingChanges());
+
+                model.restore(state1);
+
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), predicateResultSet);
                 assertFalse(queryEngine.hasPendingChanges());
         }
 }
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryAssertions.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryAssertions.java
new file mode 100644
index 00000000..6f50ec73
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryAssertions.java
@@ -0,0 +1,52 @@
+package tools.refinery.store.query.viatra.tests;
+
+import org.junit.jupiter.api.function.Executable;
+import tools.refinery.store.query.ResultSet;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.*;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.nullValue;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+public final class QueryAssertions {
+        private QueryAssertions() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static <T> void assertNullableResults(Map<Tuple, Optional<T>> expected, ResultSet<T> resultSet) {
+                var nullableValuesMap = new LinkedHashMap<Tuple, T>(expected.size());
+                for (var entry : expected.entrySet()) {
+                        nullableValuesMap.put(entry.getKey(), entry.getValue().orElse(null));
+                }
+                assertResults(nullableValuesMap, resultSet);
+        }
+
+        public static <T> void assertResults(Map<Tuple, T> expected, ResultSet<T> resultSet) {
+                var defaultValue = resultSet.getQuery().defaultValue();
+                var filteredExpected = new LinkedHashMap<Tuple, T>();
+                var executables = new ArrayList<Executable>();
+                for (var entry : expected.entrySet()) {
+                        var key = entry.getKey();
+                        var value = entry.getValue();
+                        if (!Objects.equals(value, defaultValue)) {
+                                filteredExpected.put(key, value);
+                        }
+                        executables.add(() -> assertThat("value for key " + key,resultSet.get(key), is(value)));
+                }
+                executables.add(() -> assertThat("results size", resultSet.size(), is(filteredExpected.size())));
+
+                var actual = new LinkedHashMap<Tuple, T>();
+                var cursor = resultSet.getAll();
+                while (cursor.move()) {
+                        var key = cursor.getKey();
+                        var previous = actual.put(key.toTuple(), cursor.getValue());
+                        assertThat("duplicate value for key " + key, previous, nullValue());
+                }
+                executables.add(() -> assertThat("results cursor", actual, is(filteredExpected)));
+
+                assertAll(executables);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryBackendHint.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryBackendHint.java
new file mode 100644
index 00000000..b1818a17
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryBackendHint.java
@@ -0,0 +1,22 @@
+package tools.refinery.store.query.viatra.tests;
+
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+
+/**
+ * Overrides {@link QueryEvaluationHint#toString()} for pretty names in parametric test names.
+ */
+class QueryBackendHint extends QueryEvaluationHint {
+        public QueryBackendHint(BackendRequirement backendRequirementType) {
+                super(null, backendRequirementType);
+        }
+
+        @Override
+        public String toString() {
+                return switch (getQueryBackendRequirementType()) {
+                        case UNSPECIFIED -> "default";
+                        case DEFAULT_CACHING -> "incremental";
+                        case DEFAULT_SEARCH -> "localSearch";
+                        default -> throw new IllegalStateException("Unknown BackendRequirement");
+                };
+        }
+}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryEngineTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryEngineTest.java
new file mode 100644
index 00000000..f129520c
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryEngineTest.java
@@ -0,0 +1,16 @@
+package tools.refinery.store.query.viatra.tests;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@ParameterizedTest(name = "backend = {0}")
+@ArgumentsSource(QueryEvaluationHintSource.class)
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface QueryEngineTest {
+}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryEvaluationHintSource.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryEvaluationHintSource.java
new file mode 100644
index 00000000..a55762e2
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryEvaluationHintSource.java
@@ -0,0 +1,19 @@
+package tools.refinery.store.query.viatra.tests;
+
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+
+import java.util.stream.Stream;
+
+public class QueryEvaluationHintSource implements ArgumentsProvider {
+        @Override
+        public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
+                return Stream.of(
+                                Arguments.of(new QueryBackendHint(QueryEvaluationHint.BackendRequirement.UNSPECIFIED)),
+                                Arguments.of(new QueryBackendHint(QueryEvaluationHint.BackendRequirement.DEFAULT_CACHING)),
+                                Arguments.of(new QueryBackendHint(QueryEvaluationHint.BackendRequirement.DEFAULT_SEARCH))
+                );
+        }
+}
diff --git a/subprojects/store-query/build.gradle b/subprojects/store-query/build.gradle
new file mode 100644
index 00000000..97761936
--- /dev/null
+++ b/subprojects/store-query/build.gradle
@@ -0,0 +1,9 @@
+plugins {
+        id 'refinery-java-library'
+        id 'refinery-java-test-fixtures'
+}
+
+dependencies {
+        api project(':refinery-store')
+        testFixturesApi libs.hamcrest
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/AnyResultSet.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/AnyResultSet.java
new file mode 100644
index 00000000..6d411212
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/AnyResultSet.java
@@ -0,0 +1,11 @@
+package tools.refinery.store.query;
+
+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/Constraint.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/Constraint.java
new file mode 100644
index 00000000..cec4c19f
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/Constraint.java
@@ -0,0 +1,65 @@
+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<Sort> getSorts();
+
+        default int arity() {
+                return getSorts().size();
+        }
+
+        default boolean invalidIndex(int i) {
+                return i < 0 || i >= arity();
+        }
+
+        default LiteralReduction getReduction() {
+                return LiteralReduction.NOT_REDUCIBLE;
+        }
+
+        default boolean equals(LiteralEqualityHelper helper, Constraint other) {
+                return equals(other);
+        }
+
+        String toReferenceString();
+
+        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> aggregate(DataVariable<T> inputVariable, Aggregator<R, T> aggregator,
+                                                                                          List<Variable> arguments) {
+                return targetVariable -> new AggregationLiteral<>(targetVariable, aggregator, inputVariable, this, arguments);
+        }
+
+        default <R, T> AssignedValue<R> aggregate(DataVariable<T> inputVariable, Aggregator<R, T> aggregator,
+                                                                                          Variable... arguments) {
+                return aggregate(inputVariable, aggregator, List.of(arguments));
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/EmptyResultSet.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/EmptyResultSet.java
new file mode 100644
index 00000000..9af73bdd
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/EmptyResultSet.java
@@ -0,0 +1,34 @@
+package tools.refinery.store.query;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.Cursors;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.tuple.TupleLike;
+
+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(TupleLike parameters) {
+                return query.defaultValue();
+        }
+
+
+        @Override
+        public Cursor<TupleLike, T> getAll() {
+                return Cursors.empty();
+        }
+
+        @Override
+        public int size() {
+                return 0;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/ModelQuery.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQuery.java
index 6a1aeabb..6a1aeabb 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/ModelQuery.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQuery.java
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryAdapter.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryAdapter.java
index 7449e39b..2e30fec4 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryAdapter.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryAdapter.java
@@ -1,11 +1,17 @@
 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;
 
 public interface ModelQueryAdapter extends ModelAdapter {
         ModelQueryStoreAdapter getStoreAdapter();
 
-        ResultSet getResultSet(DNF query);
+        default AnyResultSet getResultSet(AnyQuery query) {
+                return getResultSet((Query<?>) query);
+        }
+
+        <T> ResultSet<T> getResultSet(Query<T> query);
 
         boolean hasPendingChanges();
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryBuilder.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryBuilder.java
index 4364d844..4fdc9210 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryBuilder.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryBuilder.java
@@ -2,21 +2,23 @@ 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(DNF... queries) {
+        default ModelQueryBuilder queries(AnyQuery... queries) {
                 return queries(List.of(queries));
         }
 
-        default ModelQueryBuilder queries(Collection<DNF> queries) {
+        default ModelQueryBuilder queries(Collection<? extends AnyQuery> queries) {
                 queries.forEach(this::query);
                 return this;
         }
 
-        ModelQueryBuilder query(DNF query);
+        ModelQueryBuilder query(AnyQuery query);
 
         @Override
         ModelQueryStoreAdapter createStoreAdapter(ModelStore store);
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryStoreAdapter.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryStoreAdapter.java
index ef5a4587..514e582b 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/ModelQueryStoreAdapter.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/ModelQueryStoreAdapter.java
@@ -2,6 +2,7 @@ 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.AnyRelationView;
 
 import java.util.Collection;
@@ -9,7 +10,7 @@ import java.util.Collection;
 public interface ModelQueryStoreAdapter extends ModelStoreAdapter {
         Collection<AnyRelationView> getRelationViews();
 
-        Collection<DNF> getQueries();
+        Collection<AnyQuery> getQueries();
 
         @Override
         ModelQueryAdapter createModelAdapter(Model model);
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/ResultSet.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/ResultSet.java
new file mode 100644
index 00000000..3f6bc06f
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/ResultSet.java
@@ -0,0 +1,13 @@
+package tools.refinery.store.query;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.tuple.TupleLike;
+
+public non-sealed interface ResultSet<T> extends AnyResultSet {
+        Query<T> getQuery();
+
+        T get(TupleLike parameters);
+
+        Cursor<TupleLike, T> getAll();
+}
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..d0a2367f
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/AnyQuery.java
@@ -0,0 +1,11 @@
+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/Dnf.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Dnf.java
new file mode 100644
index 00000000..1b7759c7
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Dnf.java
@@ -0,0 +1,194 @@
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.equality.DnfEqualityChecker;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.literal.LiteralReduction;
+import tools.refinery.store.query.term.Sort;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public final class Dnf implements Constraint {
+        private static final String INDENTATION = "    ";
+
+        private final String name;
+
+        private final String uniqueName;
+
+        private final List<Variable> parameters;
+
+        private final List<FunctionalDependency<Variable>> functionalDependencies;
+
+        private final List<DnfClause> clauses;
+
+        Dnf(String name, List<Variable> parameters, List<FunctionalDependency<Variable>> functionalDependencies,
+                List<DnfClause> clauses) {
+                validateFunctionalDependencies(parameters, functionalDependencies);
+                this.name = name;
+                this.uniqueName = DnfUtils.generateUniqueName(name);
+                this.parameters = parameters;
+                this.functionalDependencies = functionalDependencies;
+                this.clauses = clauses;
+        }
+
+        private static void validateFunctionalDependencies(
+                        Collection<Variable> parameters, Collection<FunctionalDependency<Variable>> functionalDependencies) {
+                var parameterSet = new HashSet<>(parameters);
+                for (var functionalDependency : functionalDependencies) {
+                        validateParameters(parameters, parameterSet, functionalDependency.forEach(), functionalDependency);
+                        validateParameters(parameters, parameterSet, functionalDependency.unique(), functionalDependency);
+                }
+        }
+
+        private static void validateParameters(Collection<Variable> parameters, 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, parameters));
+                        }
+                }
+        }
+
+        @Override
+        public String name() {
+                return name == null ? uniqueName : name;
+        }
+
+        public boolean isExplicitlyNamed() {
+                return name == null;
+        }
+
+        public String getUniqueName() {
+                return uniqueName;
+        }
+
+        public List<Variable> getParameters() {
+                return parameters;
+        }
+
+        @Override
+        public List<Sort> getSorts() {
+                return parameters.stream().map(Variable::getSort).toList();
+        }
+
+        public List<FunctionalDependency<Variable>> getFunctionalDependencies() {
+                return functionalDependencies;
+        }
+
+        @Override
+        public int arity() {
+                return parameters.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 LiteralReduction getReduction() {
+                if (clauses.isEmpty()) {
+                        return LiteralReduction.ALWAYS_FALSE;
+                }
+                for (var clause : clauses) {
+                        if (clause.literals().isEmpty()) {
+                                return LiteralReduction.ALWAYS_TRUE;
+                        }
+                }
+                return LiteralReduction.NOT_REDUCIBLE;
+        }
+
+        public boolean equalsWithSubstitution(DnfEqualityChecker callEqualityChecker, Dnf other) {
+                if (arity() != other.arity()) {
+                        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, parameters, other.parameters);
+                        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 = parameters.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);
+        }
+}
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..aad5a85f
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfBuilder.java
@@ -0,0 +1,110 @@
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.*;
+
+@SuppressWarnings("UnusedReturnValue")
+public final class DnfBuilder {
+        private final String name;
+
+        private final List<Variable> 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 DnfBuilder parameter(Variable variable) {
+                if (parameters.contains(variable)) {
+                        throw new IllegalArgumentException("Duplicate parameter: " + variable);
+                }
+                parameters.add(variable);
+                return this;
+        }
+
+        public DnfBuilder parameters(Variable... variables) {
+                return parameters(List.of(variables));
+        }
+
+        public DnfBuilder parameters(Collection<? extends Variable> variables) {
+                parameters.addAll(variables);
+                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(Literal... literals) {
+                clause(List.of(literals));
+                return this;
+        }
+
+        public DnfBuilder clause(Collection<? extends Literal> literals) {
+                // Remove duplicates by using a hashed data structure.
+                var filteredLiterals = new LinkedHashSet<Literal>(literals.size());
+                for (var literal : literals) {
+                        var reduction = literal.getReduction();
+                        switch (reduction) {
+                        case NOT_REDUCIBLE -> filteredLiterals.add(literal);
+                        case ALWAYS_TRUE -> {
+                                // Literals reducible to {@code true} can be omitted, because the model is always assumed to have at
+                                // least on object.
+                        }
+                        case ALWAYS_FALSE -> {
+                                // Clauses with {@code false} literals can be omitted entirely.
+                                return this;
+                        }
+                        default -> throw new IllegalArgumentException("Invalid reduction: " + reduction);
+                        }
+                }
+                clauses.add(List.copyOf(filteredLiterals));
+                return this;
+        }
+
+        public Dnf build() {
+                var postProcessedClauses = postProcessClauses();
+                return new Dnf(name, Collections.unmodifiableList(parameters),
+                                Collections.unmodifiableList(functionalDependencies),
+                                Collections.unmodifiableList(postProcessedClauses));
+        }
+
+        <T> void output(DataVariable<T> outputVariable) {
+                functionalDependency(Set.copyOf(parameters), Set.of(outputVariable));
+                parameter(outputVariable);
+        }
+
+        private List<DnfClause> postProcessClauses() {
+                var postProcessedClauses = new ArrayList<DnfClause>(clauses.size());
+                for (var literals : clauses) {
+                        if (literals.isEmpty()) {
+                                // Predicate will always match, the other clauses are irrelevant.
+                                return List.of(new DnfClause(Set.of(), List.of()));
+                        }
+                        var variables = new HashSet<Variable>();
+                        for (var literal : literals) {
+                                variables.addAll(literal.getBoundVariables());
+                        }
+                        parameters.forEach(variables::remove);
+                        postProcessedClauses.add(new DnfClause(Collections.unmodifiableSet(variables),
+                                        Collections.unmodifiableList(literals)));
+                }
+                return postProcessedClauses;
+        }
+}
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..01830af1
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfClause.java
@@ -0,0 +1,23 @@
+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> boundVariables, 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/src/main/java/tools/refinery/store/query/DNFUtils.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfUtils.java
index 0ef77d49..9bcf944c 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/DNFUtils.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/DnfUtils.java
@@ -1,9 +1,9 @@
-package tools.refinery.store.query;
+package tools.refinery.store.query.dnf;
 
 import java.util.UUID;
 
-public final class DNFUtils {
-        private DNFUtils() {
+public final class DnfUtils {
+        private DnfUtils() {
                 throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
         }
 
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/FunctionalDependency.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalDependency.java
index 63a81713..f4cd109f 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/FunctionalDependency.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalDependency.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.query;
+package tools.refinery.store.query.dnf;
 
 import java.util.HashSet;
 import java.util.Set;
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..5bf6f8c5
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQuery.java
@@ -0,0 +1,103 @@
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.literal.CallPolarity;
+import tools.refinery.store.query.term.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public final class FunctionalQuery<T> implements Query<T> {
+        private final Dnf dnf;
+        private final Class<T> type;
+
+        FunctionalQuery(Dnf dnf, Class<T> type) {
+                var parameters = dnf.getParameters();
+                int outputIndex = dnf.arity() - 1;
+                for (int i = 0; i < outputIndex; i++) {
+                        var parameter = parameters.get(i);
+                        if (!(parameter instanceof NodeVariable)) {
+                                throw new IllegalArgumentException("Expected parameter %s of %s to be of sort %s, but got %s instead"
+                                                .formatted(parameter, dnf, NodeSort.INSTANCE, parameter.getSort()));
+                        }
+                }
+                var outputParameter = parameters.get(outputIndex);
+                if (!(outputParameter instanceof DataVariable<?> dataOutputParameter) ||
+                                !dataOutputParameter.getType().equals(type)) {
+                        throw new IllegalArgumentException("Expected parameter %s of %s to be of sort %s, but got %s instead"
+                                        .formatted(outputParameter, dnf, type, outputParameter.getSort()));
+                }
+                this.dnf = dnf;
+                this.type = type;
+        }
+
+        @Override
+        public String name() {
+                return dnf.name();
+        }
+
+        @Override
+        public int arity() {
+                return dnf.arity() - 1;
+        }
+
+        @Override
+        public Class<T> valueType() {
+                return type;
+        }
+
+        @Override
+        public T defaultValue() {
+                return null;
+        }
+
+        @Override
+        public Dnf getDnf() {
+                return dnf;
+        }
+
+        public AssignedValue<T> call(List<NodeVariable> arguments) {
+                return targetVariable -> {
+                        var argumentsWithTarget = new ArrayList<Variable>(arguments.size() + 1);
+                        argumentsWithTarget.addAll(arguments);
+                        argumentsWithTarget.add(targetVariable);
+                        return dnf.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 dnf.aggregate(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;
+                FunctionalQuery<?> that = (FunctionalQuery<?>) o;
+                return dnf.equals(that.dnf) && type.equals(that.type);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(dnf, type);
+        }
+
+        @Override
+        public String toString() {
+                return dnf.toString();
+        }
+}
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..ca2bc006
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/FunctionalQueryBuilder.java
@@ -0,0 +1,46 @@
+package tools.refinery.store.query.dnf;
+
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Collection;
+import java.util.Set;
+
+public final class FunctionalQueryBuilder<T> {
+        private final DnfBuilder dnfBuilder;
+        private final Class<T> type;
+
+        FunctionalQueryBuilder(DnfBuilder dnfBuilder, Class<T> type) {
+                this.dnfBuilder = dnfBuilder;
+                this.type = type;
+        }
+
+        public FunctionalQueryBuilder<T> functionalDependencies(Collection<FunctionalDependency<Variable>> functionalDependencies) {
+                dnfBuilder.functionalDependencies(functionalDependencies);
+                return this;
+        }
+
+        public FunctionalQueryBuilder<T> functionalDependency(FunctionalDependency<Variable> functionalDependency) {
+                dnfBuilder.functionalDependency(functionalDependency);
+                return this;
+        }
+
+        public FunctionalQueryBuilder<T> functionalDependency(Set<? extends Variable> forEach, Set<? extends Variable> unique) {
+                dnfBuilder.functionalDependency(forEach, unique);
+                return this;
+        }
+
+        public FunctionalQueryBuilder<T> clause(Literal... literals) {
+                dnfBuilder.clause(literals);
+                return this;
+        }
+
+        public FunctionalQueryBuilder<T> clause(Collection<? extends Literal> literals) {
+                dnfBuilder.clause(literals);
+                return this;
+        }
+
+        public FunctionalQuery<T> build() {
+                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..32e33052
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/Query.java
@@ -0,0 +1,16 @@
+package tools.refinery.store.query.dnf;
+
+public sealed interface Query<T> extends AnyQuery permits RelationalQuery, FunctionalQuery {
+        @Override
+        Class<T> valueType();
+
+        T defaultValue();
+
+        static QueryBuilder builder() {
+                return new QueryBuilder();
+        }
+
+        static QueryBuilder builder(String name) {
+                return new QueryBuilder(name);
+        }
+}
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..ed253cc9
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/QueryBuilder.java
@@ -0,0 +1,71 @@
+package tools.refinery.store.query.dnf;
+
+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.Variable;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+public final class QueryBuilder {
+        private final DnfBuilder dnfBuilder;
+
+        QueryBuilder(String name) {
+                dnfBuilder = Dnf.builder(name);
+        }
+
+        QueryBuilder() {
+                dnfBuilder = Dnf.builder();
+        }
+
+        public QueryBuilder parameter(NodeVariable variable) {
+                dnfBuilder.parameter(variable);
+                return this;
+        }
+
+        public QueryBuilder parameters(NodeVariable... variables) {
+                dnfBuilder.parameters(variables);
+                return this;
+        }
+
+        public QueryBuilder parameters(List<NodeVariable> variables) {
+                dnfBuilder.parameters(variables);
+                return this;
+        }
+
+        public <T> FunctionalQueryBuilder<T> output(DataVariable<T> outputVariable) {
+                dnfBuilder.output(outputVariable);
+                return new FunctionalQueryBuilder<>(dnfBuilder, outputVariable.getType());
+        }
+
+        public QueryBuilder functionalDependencies(Collection<FunctionalDependency<Variable>> functionalDependencies) {
+                dnfBuilder.functionalDependencies(functionalDependencies);
+                return this;
+        }
+
+        public QueryBuilder functionalDependency(FunctionalDependency<Variable> functionalDependency) {
+                dnfBuilder.functionalDependency(functionalDependency);
+                return this;
+        }
+
+        public QueryBuilder functionalDependency(Set<? extends Variable> forEach, Set<? extends Variable> unique) {
+                dnfBuilder.functionalDependency(forEach, unique);
+                return this;
+        }
+
+        public QueryBuilder clause(Literal... literals) {
+                dnfBuilder.clause(literals);
+                return this;
+        }
+
+        public QueryBuilder clause(Collection<? extends Literal> literals) {
+                dnfBuilder.clause(literals);
+                return this;
+        }
+
+        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..5307e509
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/dnf/RelationalQuery.java
@@ -0,0 +1,93 @@
+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.NodeSort;
+import tools.refinery.store.query.term.NodeVariable;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+public final class RelationalQuery implements Query<Boolean> {
+        private final Dnf dnf;
+
+        RelationalQuery(Dnf dnf) {
+                for (var parameter : dnf.getParameters()) {
+                        if (!(parameter instanceof NodeVariable)) {
+                                throw new IllegalArgumentException("Expected parameter %s of %s to be of sort %s, but got %s instead"
+                                                .formatted(parameter, dnf, NodeSort.INSTANCE, parameter.getSort()));
+                        }
+                }
+                this.dnf = dnf;
+        }
+
+        @Override
+        public String name() {
+                return dnf.name();
+        }
+
+        @Override
+        public int arity() {
+                return dnf.arity();
+        }
+
+        @Override
+        public Class<Boolean> valueType() {
+                return Boolean.class;
+        }
+
+        @Override
+        public Boolean defaultValue() {
+                return false;
+        }
+
+        @Override
+        public Dnf getDnf() {
+                return dnf;
+        }
+
+        public CallLiteral call(CallPolarity polarity, List<NodeVariable> arguments) {
+                return dnf.call(polarity, Collections.unmodifiableList(arguments));
+        }
+
+        public CallLiteral call(CallPolarity polarity, NodeVariable... arguments) {
+                return dnf.call(polarity, arguments);
+        }
+
+        public CallLiteral call(NodeVariable... arguments) {
+                return dnf.call(arguments);
+        }
+
+        public CallLiteral callTransitive(NodeVariable left, NodeVariable right) {
+                return dnf.callTransitive(left, right);
+        }
+
+        public AssignedValue<Integer> count(List<NodeVariable> arguments) {
+                return dnf.count(Collections.unmodifiableList(arguments));
+        }
+
+        public AssignedValue<Integer> count(NodeVariable... arguments) {
+                return dnf.count(arguments);
+        }
+
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                RelationalQuery that = (RelationalQuery) o;
+                return dnf.equals(that.dnf);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(dnf);
+        }
+
+        @Override
+        public String toString() {
+                return dnf.toString();
+        }
+}
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..c3bc3ea3
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/equality/DeepDnfEqualityChecker.java
@@ -0,0 +1,31 @@
+package tools.refinery.store.query.equality;
+
+import tools.refinery.store.query.dnf.Dnf;
+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));
+        }
+
+        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..6b1f2076
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/equality/DnfEqualityChecker.java
@@ -0,0 +1,8 @@
+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..07d261ea
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/equality/LiteralEqualityHelper.java
@@ -0,0 +1,48 @@
+package tools.refinery.store.query.equality;
+
+import tools.refinery.store.query.dnf.Dnf;
+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<Variable> leftParameters,
+                                                                 List<Variable> 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), rightParameters.get(i))) {
+                                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..657ca26b
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AbstractCallLiteral.java
@@ -0,0 +1,80 @@
+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.Variable;
+
+import java.util.List;
+import java.util.Objects;
+
+public abstract class AbstractCallLiteral implements Literal {
+        private final Constraint target;
+        private final List<Variable> arguments;
+
+        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 sorts = target.getSorts();
+                for (int i = 0; i < arity; i++) {
+                        var argument = arguments.get(i);
+                        var sort = sorts.get(i);
+                        if (!sort.isInstance(argument)) {
+                                throw new IllegalArgumentException("Required argument %d of %s to be of sort %s, but got %s instead"
+                                                .formatted(i, target, sort, argument.getSort()));
+                        }
+                }
+        }
+
+        public Constraint getTarget() {
+                return target;
+        }
+
+        public List<Variable> getArguments() {
+                return arguments;
+        }
+
+        @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(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..df64839c
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AggregationLiteral.java
@@ -0,0 +1,113 @@
+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.Aggregator;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.Variable;
+
+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 (!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(inputVariable)) {
+                        throw new IllegalArgumentException("Input variable %s must appear in the argument list".formatted(
+                                        inputVariable));
+                }
+                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> getBoundVariables() {
+                return Set.of(resultVariable);
+        }
+
+        @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..52ac42d7
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssignLiteral.java
@@ -0,0 +1,44 @@
+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.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()));
+                }
+        }
+
+        @Override
+        public Set<Variable> getBoundVariables() {
+                return Set.of(variable);
+        }
+
+        @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);
+        }
+}
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..0b4267b4
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/AssumeLiteral.java
@@ -0,0 +1,53 @@
+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.Term;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.term.bool.BoolConstantTerm;
+
+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> getBoundVariables() {
+                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 LiteralReduction getReduction() {
+                if (BoolConstantTerm.TRUE.equals(term)) {
+                        return LiteralReduction.ALWAYS_TRUE;
+                } else if (BoolConstantTerm.FALSE.equals(term)) {
+                        return LiteralReduction.ALWAYS_FALSE;
+                } else {
+                        return LiteralReduction.NOT_REDUCIBLE;
+                }
+        }
+
+        @Override
+        public String toString() {
+                return "(%s)".formatted(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..38be61a4
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/BooleanLiteral.java
@@ -0,0 +1,53 @@
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+
+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> getBoundVariables() {
+                return Set.of();
+        }
+
+        @Override
+        public Literal substitute(Substitution substitution) {
+                // No variables to substitute.
+                return this;
+        }
+
+        @Override
+        public LiteralReduction getReduction() {
+                return value ? LiteralReduction.ALWAYS_TRUE : LiteralReduction.ALWAYS_FALSE;
+        }
+
+        @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..78fae7f5
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallLiteral.java
@@ -0,0 +1,102 @@
+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.NodeSort;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+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);
+                if (polarity.isTransitive()) {
+                        if (target.arity() != 2) {
+                                throw new IllegalArgumentException("Transitive closures can only take binary relations");
+                        }
+                        var sorts = target.getSorts();
+                        if (!sorts.get(0).equals(NodeSort.INSTANCE) || !sorts.get(1).equals(NodeSort.INSTANCE)) {
+                                throw new IllegalArgumentException("Transitive closures can only be computed over nodes");
+                        }
+                }
+                this.polarity = polarity;
+        }
+
+        public CallPolarity getPolarity() {
+                return polarity;
+        }
+
+        @Override
+        public Set<Variable> getBoundVariables() {
+                return polarity.isPositive() ? Set.copyOf(getArguments()) : Set.of();
+        }
+
+        @Override
+        protected Literal doSubstitute(Substitution substitution, List<Variable> substitutedArguments) {
+                return new CallLiteral(polarity, getTarget(), substitutedArguments);
+        }
+
+        @Override
+        public LiteralReduction getReduction() {
+                var reduction = getTarget().getReduction();
+                return polarity.isPositive() ? reduction : reduction.negate();
+        }
+
+        @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/src/main/java/tools/refinery/store/query/atom/CallPolarity.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallPolarity.java
index 957e9b7b..84b4b771 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallPolarity.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CallPolarity.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.query.atom;
+package tools.refinery.store.query.literal;
 
 public enum CallPolarity {
         POSITIVE(true, false),
@@ -22,7 +22,11 @@ public enum CallPolarity {
                 return transitive;
         }
 
-        public static CallPolarity fromBoolean(boolean positive) {
-                return positive ? POSITIVE : NEGATIVE;
+        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..3e159c43
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CanNegate.java
@@ -0,0 +1,5 @@
+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..93fa3df0
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/ConstantLiteral.java
@@ -0,0 +1,34 @@
+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.Set;
+
+public record ConstantLiteral(NodeVariable variable, int nodeId) implements Literal {
+        @Override
+        public Set<Variable> getBoundVariables() {
+                return Set.of(variable);
+        }
+
+        @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);
+        }
+}
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..32e7ba3a
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/CountLiteral.java
@@ -0,0 +1,83 @@
+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 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> getBoundVariables() {
+                return Set.of(resultVariable);
+        }
+
+        @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..4dc86b98
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/EquivalenceLiteral.java
@@ -0,0 +1,52 @@
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.term.NodeVariable;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+
+import java.util.Set;
+
+public record EquivalenceLiteral(boolean positive, NodeVariable left, NodeVariable right)
+                implements CanNegate<EquivalenceLiteral> {
+        @Override
+        public Set<Variable> getBoundVariables() {
+                // If one side of a {@code positive} equivalence is bound, it may bind its other side, but we under-approximate
+                // this behavior by not binding any of the sides by default.
+                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 LiteralReduction getReduction() {
+                if (left.equals(right)) {
+                        return positive ? LiteralReduction.ALWAYS_TRUE : LiteralReduction.ALWAYS_FALSE;
+                }
+                return LiteralReduction.NOT_REDUCIBLE;
+        }
+
+        @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);
+        }
+}
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..6347410e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/Literal.java
@@ -0,0 +1,20 @@
+package tools.refinery.store.query.literal;
+
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+
+import java.util.Set;
+
+public interface Literal {
+        Set<Variable> getBoundVariables();
+
+        Literal substitute(Substitution substitution);
+
+        default LiteralReduction getReduction() {
+                return LiteralReduction.NOT_REDUCIBLE;
+        }
+
+        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+        boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other);
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/LiteralReduction.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/LiteralReduction.java
new file mode 100644
index 00000000..146089f6
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/LiteralReduction.java
@@ -0,0 +1,26 @@
+package tools.refinery.store.query.literal;
+
+public enum LiteralReduction {
+        /**
+         * 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 LiteralReduction 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/literal/Literals.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/Literals.java
new file mode 100644
index 00000000..89039352
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/Literals.java
@@ -0,0 +1,17 @@
+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/substitution/CompositeSubstitution.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/CompositeSubstitution.java
new file mode 100644
index 00000000..f8064ca2
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/CompositeSubstitution.java
@@ -0,0 +1,10 @@
+package tools.refinery.store.query.substitution;
+
+import tools.refinery.store.query.term.Variable;
+
+public record CompositeSubstitution(Substitution first, Substitution second) implements Substitution {
+        @Override
+        public Variable getSubstitute(Variable variable) {
+                return second.getSubstitute(first.getSubstitute(variable));
+        }
+}
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..c7754619
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/MapBasedSubstitution.java
@@ -0,0 +1,13 @@
+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..7847e582
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/RenewingSubstitution.java
@@ -0,0 +1,15 @@
+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..eed414d9
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/StatelessSubstitution.java
@@ -0,0 +1,18 @@
+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..99f84b9e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/Substitution.java
@@ -0,0 +1,29 @@
+package tools.refinery.store.query.substitution;
+
+import tools.refinery.store.query.term.AnyDataVariable;
+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 AnyDataVariable getTypeSafeSubstitute(AnyDataVariable variable) {
+                return getTypeSafeSubstitute((DataVariable<?>) variable);
+        }
+
+        default <T> DataVariable<T> getTypeSafeSubstitute(DataVariable<T> variable) {
+                var substitute = getSubstitute(variable);
+                return substitute.asDataVariable(variable.getType());
+        }
+
+        default Substitution andThen(Substitution second) {
+                return new CompositeSubstitution(this, second);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/Substitutions.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/Substitutions.java
new file mode 100644
index 00000000..5d4654da
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/substitution/Substitutions.java
@@ -0,0 +1,33 @@
+package tools.refinery.store.query.substitution;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.Map;
+
+public final class Substitutions {
+        private Substitutions() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiate directly");
+        }
+
+        public static Substitution total(Map<Variable, Variable> map) {
+                return new MapBasedSubstitution(map, StatelessSubstitution.FAILING);
+        }
+
+        public static Substitution partial(Map<Variable, Variable> map) {
+                return new MapBasedSubstitution(map, StatelessSubstitution.IDENTITY);
+        }
+
+        public static Substitution renewing(Map<Variable, Variable> map) {
+                return new MapBasedSubstitution(map, renewing());
+        }
+
+        public static Substitution renewing() {
+                return new RenewingSubstitution();
+        }
+
+        public static Substitution compose(@Nullable Substitution first, @NotNull Substitution second) {
+                return first == null ? second : first.andThen(second);
+        }
+}
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..47421a94
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Aggregator.java
@@ -0,0 +1,13 @@
+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..ecfefcf9
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyDataVariable.java
@@ -0,0 +1,33 @@
+package tools.refinery.store.query.term;
+
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+
+import java.util.Set;
+
+public abstract sealed class AnyDataVariable extends Variable implements AnyTerm permits DataVariable {
+        protected AnyDataVariable(String name) {
+                super(name);
+        }
+
+        @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 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..8f998d45
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AnyTerm.java
@@ -0,0 +1,16 @@
+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/ArithmeticBinaryOperator.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ArithmeticBinaryOperator.java
new file mode 100644
index 00000000..8706a046
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ArithmeticBinaryOperator.java
@@ -0,0 +1,26 @@
+package tools.refinery.store.query.term;
+
+public enum ArithmeticBinaryOperator {
+        ADD("+", true),
+        SUB("-", true),
+        MUL("*", true),
+        DIV("/", true),
+        POW("**", true),
+        MIN("min", false),
+        MAX("max", false);
+
+        private final String text;
+        private final boolean infix;
+
+        ArithmeticBinaryOperator(String text, boolean infix) {
+                this.text = text;
+                this.infix = infix;
+        }
+
+        public String formatString(String left, String right) {
+                if (infix) {
+                        return "(%s) %s (%s)".formatted(left, text, right);
+                }
+                return "%s(%s, %s)".formatted(text, left, right);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ArithmeticBinaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ArithmeticBinaryTerm.java
new file mode 100644
index 00000000..887a1e6e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ArithmeticBinaryTerm.java
@@ -0,0 +1,56 @@
+package tools.refinery.store.query.term;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+
+import java.util.Objects;
+
+public abstract class ArithmeticBinaryTerm<T> extends BinaryTerm<T, T, T> {
+        private final ArithmeticBinaryOperator operator;
+
+        protected ArithmeticBinaryTerm(ArithmeticBinaryOperator operator, Term<T> left, Term<T> right) {
+                super(left, right);
+                this.operator = operator;
+        }
+
+        @Override
+        public Class<T> getLeftType() {
+                return getType();
+        }
+
+        @Override
+        public Class<T> getRightType() {
+                return getType();
+        }
+
+        public ArithmeticBinaryOperator getOperator() {
+                return operator;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, AnyTerm other) {
+                if (!super.equalsWithSubstitution(helper, other)) {
+                        return false;
+                }
+                var otherArithmeticBinaryTerm = (ArithmeticBinaryTerm<?>) other;
+                return operator == otherArithmeticBinaryTerm.operator;
+        }
+
+        @Override
+        public String toString() {
+                return operator.formatString(getLeft().toString(), getRight().toString());
+        }
+
+        @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;
+                ArithmeticBinaryTerm<?> that = (ArithmeticBinaryTerm<?>) o;
+                return operator == that.operator;
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), operator);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ArithmeticUnaryOperator.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ArithmeticUnaryOperator.java
new file mode 100644
index 00000000..6a7c25db
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ArithmeticUnaryOperator.java
@@ -0,0 +1,16 @@
+package tools.refinery.store.query.term;
+
+public enum ArithmeticUnaryOperator {
+        PLUS("+"),
+        MINUS("-");
+
+        private final String prefix;
+
+        ArithmeticUnaryOperator(String prefix) {
+                this.prefix = prefix;
+        }
+
+        public String formatString(String body) {
+                return "%s(%s)".formatted(prefix, body);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ArithmeticUnaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ArithmeticUnaryTerm.java
new file mode 100644
index 00000000..b78239c7
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ArithmeticUnaryTerm.java
@@ -0,0 +1,51 @@
+package tools.refinery.store.query.term;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+
+import java.util.Objects;
+
+public abstract class ArithmeticUnaryTerm<T> extends UnaryTerm<T, T> {
+        private final ArithmeticUnaryOperator operator;
+
+        protected ArithmeticUnaryTerm(ArithmeticUnaryOperator operator, Term<T> body) {
+                super(body);
+                this.operator = operator;
+        }
+
+        @Override
+        public Class<T> getBodyType() {
+                return getType();
+        }
+
+        public ArithmeticUnaryOperator getOperator() {
+                return operator;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, AnyTerm other) {
+                if (!super.equalsWithSubstitution(helper, other)) {
+                        return false;
+                }
+                var otherArithmeticUnaryTerm = (ArithmeticUnaryTerm<?>) other;
+                return operator == otherArithmeticUnaryTerm.operator;
+        }
+
+        @Override
+        public String toString() {
+                return operator.formatString(getBody().toString());
+        }
+
+        @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;
+                ArithmeticUnaryTerm<?> that = (ArithmeticUnaryTerm<?>) o;
+                return operator == that.operator;
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), operator);
+        }
+}
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..465e690f
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/AssignedValue.java
@@ -0,0 +1,8 @@
+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..34f48ccc
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/BinaryTerm.java
@@ -0,0 +1,93 @@
+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> implements Term<R> {
+        private final Term<T1> left;
+        private final Term<T2> right;
+
+        protected BinaryTerm(Term<T1> left, Term<T2> right) {
+                if (!left.getType().equals(getLeftType())) {
+                        throw new IllegalArgumentException("Expected left %s to be of type %s, got %s instead".formatted(left,
+                                        getLeftType().getName(), left.getType().getName()));
+                }
+                if (!right.getType().equals(getRightType())) {
+                        throw new IllegalArgumentException("Expected right %s to be of type %s, got %s instead".formatted(right,
+                                        getRightType().getName(), right.getType().getName()));
+                }
+                this.left = left;
+                this.right = right;
+        }
+
+        public abstract Class<T1> getLeftType();
+
+        public abstract Class<T2> getRightType();
+
+        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 (getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherBinaryTerm = (BinaryTerm<?, ?, ?>) other;
+                return 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;
+                BinaryTerm<?, ?, ?> that = (BinaryTerm<?, ?, ?>) o;
+                return left.equals(that.left) && right.equals(that.right);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(getClass(), left, right);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ComparisonOperator.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ComparisonOperator.java
new file mode 100644
index 00000000..44dcce10
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ComparisonOperator.java
@@ -0,0 +1,20 @@
+package tools.refinery.store.query.term;
+
+public enum ComparisonOperator {
+        EQ("=="),
+        NOT_EQ("!="),
+        LESS("<"),
+        LESS_EQ("<="),
+        GREATER(">"),
+        GREATER_EQ(">=");
+
+        private final String text;
+
+        ComparisonOperator(String text) {
+                this.text = text;
+        }
+
+        public String formatString(String left, String right) {
+                return "(%s) %s (%s)".formatted(left, text, right);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ComparisonTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ComparisonTerm.java
new file mode 100644
index 00000000..320d42df
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ComparisonTerm.java
@@ -0,0 +1,63 @@
+package tools.refinery.store.query.term;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+
+import java.util.Objects;
+
+public abstract class ComparisonTerm<T> extends BinaryTerm<Boolean, T, T> {
+        private final ComparisonOperator operator;
+
+        protected ComparisonTerm(ComparisonOperator operator, Term<T> left, Term<T> right) {
+                super(left, right);
+                this.operator = operator;
+        }
+
+        @Override
+        public Class<Boolean> getType() {
+                return Boolean.class;
+        }
+
+        public abstract Class<T> getOperandType();
+
+        @Override
+        public Class<T> getLeftType() {
+                return getOperandType();
+        }
+
+        @Override
+        public Class<T> getRightType() {
+                return getOperandType();
+        }
+
+        public ComparisonOperator getOperator() {
+                return operator;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, AnyTerm other) {
+                if (!super.equalsWithSubstitution(helper, other)) {
+                        return false;
+                }
+                var otherComparisonTerm = (ComparisonTerm<?>) other;
+                return operator == otherComparisonTerm.operator;
+        }
+
+        @Override
+        public String toString() {
+                return operator.formatString(getLeft().toString(), getRight().toString());
+        }
+
+        @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;
+                ComparisonTerm<?> that = (ComparisonTerm<?>) o;
+                return operator == that.operator;
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), operator);
+        }
+}
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..2185fe37
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ConstantTerm.java
@@ -0,0 +1,52 @@
+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.Set;
+
+public record ConstantTerm<T>(Class<T> type, T value) implements Term<T> {
+        public ConstantTerm {
+                if (value == null) {
+                        throw new IllegalArgumentException("value should not be null");
+                }
+                if (!type.isInstance(value)) {
+                        throw new IllegalArgumentException("value %s is not an instance of %s".formatted(value, type.getName()));
+                }
+        }
+
+        @Override
+        public Class<T> getType() {
+                return type;
+        }
+
+        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) {
+                return equals(other);
+        }
+
+        @Override
+        public Set<AnyDataVariable> getInputVariables() {
+                return Set.of();
+        }
+
+        @Override
+        public String toString() {
+                return getValue().toString();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataSort.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataSort.java
new file mode 100644
index 00000000..4fb44492
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataSort.java
@@ -0,0 +1,29 @@
+package tools.refinery.store.query.term;
+
+import org.jetbrains.annotations.Nullable;
+
+public record DataSort<T>(Class<T> type) implements Sort {
+        public static final DataSort<Integer> INT = new DataSort<>(Integer.class);
+
+        public static final DataSort<Boolean> BOOL = new DataSort<>(Boolean.class);
+
+        @Override
+        public boolean isInstance(Variable variable) {
+                return variable instanceof DataVariable<?> dataVariable && type.equals(dataVariable.getType());
+        }
+
+        @Override
+        public DataVariable<T> newInstance(@Nullable String name) {
+                return Variable.of(name, type);
+        }
+
+        @Override
+        public DataVariable<T> newInstance() {
+                return newInstance(null);
+        }
+
+        @Override
+        public String toString() {
+                return type.getName();
+        }
+}
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..af070ca7
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/DataVariable.java
@@ -0,0 +1,87 @@
+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 DataSort<T> getSort() {
+                return new DataSort<>(getType());
+        }
+
+        @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 NodeVariable asNodeVariable() {
+                throw new IllegalStateException("%s is a data variable".formatted(this));
+        }
+
+        @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..57ff597c
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/ExtremeValueAggregator.java
@@ -0,0 +1,103 @@
+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/NodeSort.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeSort.java
new file mode 100644
index 00000000..1a4b2d4b
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeSort.java
@@ -0,0 +1,30 @@
+package tools.refinery.store.query.term;
+
+import org.jetbrains.annotations.Nullable;
+
+public final class NodeSort implements Sort {
+        public static final NodeSort INSTANCE = new NodeSort();
+
+        private NodeSort() {
+        }
+
+        @Override
+        public boolean isInstance(Variable variable) {
+                return variable instanceof NodeVariable;
+        }
+
+        @Override
+        public NodeVariable newInstance(@Nullable String name) {
+                return new NodeVariable(name);
+        }
+
+        @Override
+        public NodeVariable newInstance() {
+                return newInstance(null);
+        }
+
+        @Override
+        public String toString() {
+                return "<node>";
+        }
+}
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..7419aaad
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/NodeVariable.java
@@ -0,0 +1,48 @@
+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;
+
+public final class NodeVariable extends Variable {
+        NodeVariable(@Nullable String name) {
+                super(name);
+        }
+
+        @Override
+        public NodeSort getSort() {
+                return NodeSort.INSTANCE;
+        }
+
+        @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/OpaqueTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/OpaqueTerm.java
new file mode 100644
index 00000000..8faa9c75
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/OpaqueTerm.java
@@ -0,0 +1,80 @@
+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.substitution.Substitutions;
+import tools.refinery.store.query.valuation.Valuation;
+
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public final class OpaqueTerm<T> implements Term<T> {
+        private final Class<T> type;
+        private final Function<? super Valuation, ? extends T> evaluator;
+        private final Set<AnyDataVariable> variables;
+        private final Substitution substitution;
+
+        public OpaqueTerm(Class<T> type, Function<? super Valuation, ? extends T> evaluator,
+                                          Set<? extends AnyDataVariable> variables) {
+                this(type, evaluator, variables, null);
+        }
+
+        private OpaqueTerm(Class<T> type, Function<? super Valuation, ? extends T> evaluator,
+                                           Set<? extends AnyDataVariable> variables, Substitution substitution) {
+                this.type = type;
+                this.evaluator = evaluator;
+                this.variables = Set.copyOf(variables);
+                this.substitution = substitution;
+        }
+
+        @Override
+        public Class<T> getType() {
+                return type;
+        }
+
+        @Override
+        public Set<AnyDataVariable> getInputVariables() {
+                return variables;
+        }
+
+        @Override
+        public T evaluate(Valuation valuation) {
+                return evaluator.apply(valuation.substitute(substitution));
+        }
+
+        @Override
+        public Term<T> substitute(Substitution newSubstitution) {
+                var substitutedVariables = variables.stream()
+                                .map(newSubstitution::getTypeSafeSubstitute)
+                                .collect(Collectors.toUnmodifiableSet());
+                return new OpaqueTerm<>(type, evaluator, substitutedVariables,
+                                Substitutions.compose(substitution, newSubstitution));
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, AnyTerm other) {
+                // Cannot inspect the opaque evaluator for deep equality.
+                return equals(other);
+        }
+
+        @Override
+        public String toString() {
+                return "<opaque>";
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                OpaqueTerm<?> that = (OpaqueTerm<?>) o;
+                return type.equals(that.type) && evaluator.equals(that.evaluator) && Objects.equals(substitution,
+                                that.substitution);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(type, evaluator, substitution);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Sort.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Sort.java
new file mode 100644
index 00000000..622bcfce
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Sort.java
@@ -0,0 +1,11 @@
+package tools.refinery.store.query.term;
+
+import org.jetbrains.annotations.Nullable;
+
+public sealed interface Sort permits DataSort, NodeSort {
+        boolean isInstance(Variable variable);
+
+        Variable newInstance(@Nullable String name);
+
+        Variable newInstance();
+}
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..7ce91305
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/StatefulAggregate.java
@@ -0,0 +1,17 @@
+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..c215a511
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/StatefulAggregator.java
@@ -0,0 +1,23 @@
+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..74dbd335
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/StatelessAggregator.java
@@ -0,0 +1,20 @@
+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..95434db2
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Term.java
@@ -0,0 +1,21 @@
+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..4083111a
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/UnaryTerm.java
@@ -0,0 +1,68 @@
+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> implements Term<R> {
+        private final Term<T> body;
+
+        protected UnaryTerm(Term<T> body) {
+                if (!body.getType().equals(getBodyType())) {
+                        throw new IllegalArgumentException("Expected body %s to be of type %s, got %s instead".formatted(body,
+                                        getBodyType().getName(), body.getType().getName()));
+                }
+                this.body = body;
+        }
+
+        public abstract Class<T> getBodyType();
+
+        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 (getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherUnaryTerm = (UnaryTerm<?, ?>) other;
+                return 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;
+                UnaryTerm<?, ?> unaryTerm = (UnaryTerm<?, ?>) o;
+                return body.equals(unaryTerm.body);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(getClass(), 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..957e10f8
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/Variable.java
@@ -0,0 +1,76 @@
+package tools.refinery.store.query.term;
+
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.query.dnf.DnfUtils;
+
+import java.util.Objects;
+
+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 Sort getSort();
+
+        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 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/BoolConstantTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolConstantTerm.java
new file mode 100644
index 00000000..5079f1ce
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolConstantTerm.java
@@ -0,0 +1,16 @@
+package tools.refinery.store.query.term.bool;
+
+import tools.refinery.store.query.term.ConstantTerm;
+
+public final class BoolConstantTerm {
+        public static final ConstantTerm<Boolean> TRUE = new ConstantTerm<>(Boolean.class, true);
+        public static final ConstantTerm<Boolean> FALSE = new ConstantTerm<>(Boolean.class, false);
+
+        private BoolConstantTerm() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static ConstantTerm<Boolean> valueOf(boolean boolValue) {
+                return boolValue ? TRUE : FALSE;
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolLogicBinaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolLogicBinaryTerm.java
new file mode 100644
index 00000000..d85f864d
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolLogicBinaryTerm.java
@@ -0,0 +1,78 @@
+package tools.refinery.store.query.term.bool;
+
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.*;
+
+import java.util.Objects;
+
+public class BoolLogicBinaryTerm extends BinaryTerm<Boolean, Boolean, Boolean> {
+        private final LogicBinaryOperator operator;
+
+        protected BoolLogicBinaryTerm(LogicBinaryOperator operator, Term<Boolean> left, Term<Boolean> right) {
+                super(left, right);
+                this.operator = operator;
+        }
+
+        @Override
+        public Class<Boolean> getType() {
+                return Boolean.class;
+        }
+
+        @Override
+        public Class<Boolean> getLeftType() {
+                return getType();
+        }
+
+        @Override
+        public Class<Boolean> getRightType() {
+                return getType();
+        }
+
+        public LogicBinaryOperator getOperator() {
+                return operator;
+        }
+
+        @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, AnyTerm other) {
+                if (!super.equalsWithSubstitution(helper, other)) {
+                        return false;
+                }
+                var otherBoolLogicBinaryTerm = (BoolLogicBinaryTerm) other;
+                return operator == otherBoolLogicBinaryTerm.operator;
+        }
+
+        @Override
+        public Term<Boolean> doSubstitute(Substitution substitution, Term<Boolean> substitutedLeft,
+                                                                          Term<Boolean> substitutedRight) {
+                return new BoolLogicBinaryTerm(getOperator(), substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Boolean doEvaluate(Boolean leftValue, Boolean rightValue) {
+                return switch (getOperator()) {
+                        case AND -> leftValue && rightValue;
+                        case OR -> leftValue || rightValue;
+                        case XOR -> leftValue ^ rightValue;
+                };
+        }
+
+        @Override
+        public String toString() {
+                return operator.formatString(getLeft().toString(), getRight().toString());
+        }
+
+        @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;
+                BoolLogicBinaryTerm that = (BoolLogicBinaryTerm) o;
+                return operator == that.operator;
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), operator);
+        }
+}
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..855139b5
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolNotTerm.java
@@ -0,0 +1,36 @@
+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(body);
+        }
+
+        @Override
+        public Class<Boolean> getType() {
+                return Boolean.class;
+        }
+
+        @Override
+        public Class<Boolean> getBodyType() {
+                return getType();
+        }
+
+        @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/BoolTerms.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolTerms.java
new file mode 100644
index 00000000..3d6c8d9d
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/BoolTerms.java
@@ -0,0 +1,30 @@
+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 ConstantTerm<Boolean> constant(boolean value) {
+                return BoolConstantTerm.valueOf(value);
+        }
+
+        public static BoolNotTerm not(Term<Boolean> body) {
+                return new BoolNotTerm(body);
+        }
+
+        public static BoolLogicBinaryTerm and(Term<Boolean> left, Term<Boolean> right) {
+                return new BoolLogicBinaryTerm(LogicBinaryOperator.AND, left, right);
+        }
+
+        public static BoolLogicBinaryTerm or(Term<Boolean> left, Term<Boolean> right) {
+                return new BoolLogicBinaryTerm(LogicBinaryOperator.OR, left, right);
+        }
+
+        public static BoolLogicBinaryTerm xor(Term<Boolean> left, Term<Boolean> right) {
+                return new BoolLogicBinaryTerm(LogicBinaryOperator.XOR, left, right);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/LogicBinaryOperator.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/LogicBinaryOperator.java
new file mode 100644
index 00000000..ca9ac66e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/bool/LogicBinaryOperator.java
@@ -0,0 +1,17 @@
+package tools.refinery.store.query.term.bool;
+
+public enum LogicBinaryOperator {
+        AND("&&"),
+        OR("||"),
+        XOR("^^");
+
+        private final String text;
+
+        LogicBinaryOperator(String text) {
+                this.text = text;
+        }
+
+        public String formatString(String left, String right) {
+                return "(%s) %s (%s)".formatted(left, text, right);
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntArithmeticBinaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntArithmeticBinaryTerm.java
new file mode 100644
index 00000000..32e41718
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntArithmeticBinaryTerm.java
@@ -0,0 +1,48 @@
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.ArithmeticBinaryOperator;
+import tools.refinery.store.query.term.ArithmeticBinaryTerm;
+import tools.refinery.store.query.term.Term;
+
+public class IntArithmeticBinaryTerm extends ArithmeticBinaryTerm<Integer> {
+        public IntArithmeticBinaryTerm(ArithmeticBinaryOperator operator, Term<Integer> left, Term<Integer> right) {
+                super(operator, left, right);
+        }
+
+        @Override
+        public Class<Integer> getType() {
+                return Integer.class;
+        }
+
+        @Override
+        public Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                                                          Term<Integer> substitutedRight) {
+                return new IntArithmeticBinaryTerm(getOperator(), substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer leftValue, Integer rightValue) {
+                return switch (getOperator()) {
+                        case ADD -> leftValue + rightValue;
+                        case SUB -> leftValue - rightValue;
+                        case MUL -> leftValue * rightValue;
+                        case DIV -> rightValue == 0 ? null : leftValue / rightValue;
+                        case POW -> rightValue < 0 ? null : power(leftValue, rightValue);
+                        case MIN -> Math.min(leftValue, rightValue);
+                        case MAX -> Math.max(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;
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntArithmeticUnaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntArithmeticUnaryTerm.java
new file mode 100644
index 00000000..1e769259
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntArithmeticUnaryTerm.java
@@ -0,0 +1,30 @@
+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.ArithmeticUnaryOperator;
+import tools.refinery.store.query.term.ArithmeticUnaryTerm;
+
+public class IntArithmeticUnaryTerm extends ArithmeticUnaryTerm<Integer> {
+        public IntArithmeticUnaryTerm(ArithmeticUnaryOperator operation, Term<Integer> body) {
+                super(operation, body);
+        }
+
+        @Override
+        public Class<Integer> getType() {
+                return Integer.class;
+        }
+
+        @Override
+        protected Term<Integer> doSubstitute(Substitution substitution, Term<Integer> substitutedBody) {
+                return new IntArithmeticUnaryTerm(getOperator(), substitutedBody);
+        }
+
+        @Override
+        protected Integer doEvaluate(Integer bodyValue) {
+                return switch(getOperator()) {
+                        case PLUS -> bodyValue;
+                        case MINUS -> -bodyValue;
+                };
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntComparisonTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntComparisonTerm.java
new file mode 100644
index 00000000..322d2b80
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntComparisonTerm.java
@@ -0,0 +1,34 @@
+package tools.refinery.store.query.term.int_;
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.ComparisonOperator;
+import tools.refinery.store.query.term.ComparisonTerm;
+import tools.refinery.store.query.term.Term;
+
+public class IntComparisonTerm extends ComparisonTerm<Integer> {
+        public IntComparisonTerm(ComparisonOperator operator, Term<Integer> left, Term<Integer> right) {
+                super(operator, left, right);
+        }
+
+        @Override
+        public Class<Integer> getOperandType() {
+                return Integer.class;
+        }
+
+        @Override
+        public Term<Boolean> doSubstitute(Substitution substitution, Term<Integer> substitutedLeft,
+                                                                          Term<Integer> substitutedRight) {
+                return new IntComparisonTerm(getOperator(), substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Boolean doEvaluate(Integer leftValue, Integer rightValue) {
+                return switch (getOperator()) {
+                        case EQ -> leftValue.equals(rightValue);
+                        case NOT_EQ -> !leftValue.equals(rightValue);
+                        case LESS -> leftValue < rightValue;
+                        case LESS_EQ -> leftValue <= rightValue;
+                        case GREATER -> leftValue > rightValue;
+                        case GREATER_EQ -> leftValue >= rightValue;
+                };
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntExtremeValueAggregator.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntExtremeValueAggregator.java
new file mode 100644
index 00000000..d5a6add0
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntExtremeValueAggregator.java
@@ -0,0 +1,17 @@
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.term.ExtremeValueAggregator;
+
+import java.util.Comparator;
+
+public final class IntExtremeValueAggregator {
+        public static final ExtremeValueAggregator<Integer> MINIMUM = new ExtremeValueAggregator<>(Integer.class,
+                        Integer.MAX_VALUE);
+
+        public static final ExtremeValueAggregator<Integer> MAXIMUM = new ExtremeValueAggregator<>(Integer.class,
+                        Integer.MIN_VALUE, Comparator.reverseOrder());
+
+        private IntExtremeValueAggregator() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+}
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..65024f52
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntSumAggregator.java
@@ -0,0 +1,35 @@
+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..86594deb
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/IntTerms.java
@@ -0,0 +1,81 @@
+package tools.refinery.store.query.term.int_;
+
+import tools.refinery.store.query.term.*;
+
+public final class IntTerms {
+        public static final Aggregator<Integer, Integer> INT_SUM = IntSumAggregator.INSTANCE;
+        public static final Aggregator<Integer, Integer> INT_MIN = IntExtremeValueAggregator.MINIMUM;
+        public static final Aggregator<Integer, Integer> INT_MAX = IntExtremeValueAggregator.MAXIMUM;
+
+        private IntTerms() {
+                throw new IllegalArgumentException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static ConstantTerm<Integer> constant(int value) {
+                return new ConstantTerm<>(Integer.class, value);
+        }
+
+        public static IntArithmeticUnaryTerm plus(Term<Integer> body) {
+                return new IntArithmeticUnaryTerm(ArithmeticUnaryOperator.PLUS, body);
+        }
+
+        public static IntArithmeticUnaryTerm minus(Term<Integer> body) {
+                return new IntArithmeticUnaryTerm(ArithmeticUnaryOperator.MINUS, body);
+        }
+
+        public static IntArithmeticBinaryTerm add(Term<Integer> left, Term<Integer> right) {
+                return new IntArithmeticBinaryTerm(ArithmeticBinaryOperator.ADD, left, right);
+        }
+
+        public static IntArithmeticBinaryTerm sub(Term<Integer> left, Term<Integer> right) {
+                return new IntArithmeticBinaryTerm(ArithmeticBinaryOperator.SUB, left, right);
+        }
+
+        public static IntArithmeticBinaryTerm mul(Term<Integer> left, Term<Integer> right) {
+                return new IntArithmeticBinaryTerm(ArithmeticBinaryOperator.MUL, left, right);
+        }
+
+        public static IntArithmeticBinaryTerm div(Term<Integer> left, Term<Integer> right) {
+                return new IntArithmeticBinaryTerm(ArithmeticBinaryOperator.DIV, left, right);
+        }
+
+        public static IntArithmeticBinaryTerm pow(Term<Integer> left, Term<Integer> right) {
+                return new IntArithmeticBinaryTerm(ArithmeticBinaryOperator.POW, left, right);
+        }
+
+        public static IntArithmeticBinaryTerm min(Term<Integer> left, Term<Integer> right) {
+                return new IntArithmeticBinaryTerm(ArithmeticBinaryOperator.MIN, left, right);
+        }
+
+        public static IntArithmeticBinaryTerm max(Term<Integer> left, Term<Integer> right) {
+                return new IntArithmeticBinaryTerm(ArithmeticBinaryOperator.MAX, left, right);
+        }
+
+        public static IntComparisonTerm eq(Term<Integer> left, Term<Integer> right) {
+                return new IntComparisonTerm(ComparisonOperator.EQ, left, right);
+        }
+
+        public static IntComparisonTerm notEq(Term<Integer> left, Term<Integer> right) {
+                return new IntComparisonTerm(ComparisonOperator.NOT_EQ, left, right);
+        }
+
+        public static IntComparisonTerm less(Term<Integer> left, Term<Integer> right) {
+                return new IntComparisonTerm(ComparisonOperator.LESS, left, right);
+        }
+
+        public static IntComparisonTerm lessEq(Term<Integer> left, Term<Integer> right) {
+                return new IntComparisonTerm(ComparisonOperator.LESS_EQ, left, right);
+        }
+
+        public static IntComparisonTerm greater(Term<Integer> left, Term<Integer> right) {
+                return new IntComparisonTerm(ComparisonOperator.GREATER, left, right);
+        }
+
+        public static IntComparisonTerm greaterEq(Term<Integer> left, Term<Integer> right) {
+                return new IntComparisonTerm(ComparisonOperator.GREATER_EQ, left, right);
+        }
+
+        public static RealToIntTerm asInt(Term<Double> body) {
+                return new RealToIntTerm(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..53875ddc
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/int_/RealToIntTerm.java
@@ -0,0 +1,36 @@
+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(body);
+        }
+
+        @Override
+        public Class<Integer> getType() {
+                return Integer.class;
+        }
+
+        @Override
+        public Class<Double> getBodyType() {
+                return Double.class;
+        }
+
+        @Override
+        protected Integer doEvaluate(Double bodyValue) {
+                return 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..55590824
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/IntToRealTerm.java
@@ -0,0 +1,36 @@
+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(body);
+        }
+
+        @Override
+        public Class<Double> getType() {
+                return Double.class;
+        }
+
+        @Override
+        public Class<Integer> getBodyType() {
+                return Integer.class;
+        }
+
+        @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/RealArithmeticBinaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealArithmeticBinaryTerm.java
new file mode 100644
index 00000000..57bcbe5e
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealArithmeticBinaryTerm.java
@@ -0,0 +1,36 @@
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.ArithmeticBinaryOperator;
+import tools.refinery.store.query.term.ArithmeticBinaryTerm;
+import tools.refinery.store.query.term.Term;
+
+public class RealArithmeticBinaryTerm extends ArithmeticBinaryTerm<Double> {
+        public RealArithmeticBinaryTerm(ArithmeticBinaryOperator operator, Term<Double> left, Term<Double> right) {
+                super(operator, left, right);
+        }
+
+        @Override
+        public Class<Double> getType() {
+                return Double.class;
+        }
+
+        @Override
+        public Term<Double> doSubstitute(Substitution substitution, Term<Double> substitutedLeft,
+                                                                         Term<Double> substitutedRight) {
+                return new RealArithmeticBinaryTerm(getOperator(), substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Double doEvaluate(Double leftValue, Double rightValue) {
+                return switch (getOperator()) {
+                        case ADD -> leftValue + rightValue;
+                        case SUB -> leftValue - rightValue;
+                        case MUL -> leftValue * rightValue;
+                        case DIV -> leftValue / rightValue;
+                        case POW -> Math.pow(leftValue, rightValue);
+                        case MIN -> Math.min(leftValue, rightValue);
+                        case MAX -> Math.max(leftValue, rightValue);
+                };
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealArithmeticUnaryTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealArithmeticUnaryTerm.java
new file mode 100644
index 00000000..632e68bf
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealArithmeticUnaryTerm.java
@@ -0,0 +1,30 @@
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.ArithmeticUnaryOperator;
+import tools.refinery.store.query.term.ArithmeticUnaryTerm;
+import tools.refinery.store.query.term.Term;
+
+public class RealArithmeticUnaryTerm extends ArithmeticUnaryTerm<Double> {
+        public RealArithmeticUnaryTerm(ArithmeticUnaryOperator operation, Term<Double> body) {
+                super(operation, body);
+        }
+
+        @Override
+        public Class<Double> getType() {
+                return Double.class;
+        }
+
+        @Override
+        protected Term<Double> doSubstitute(Substitution substitution, Term<Double> substitutedBody) {
+                return new RealArithmeticUnaryTerm(getOperator(), substitutedBody);
+        }
+
+        @Override
+        protected Double doEvaluate(Double bodyValue) {
+                return switch(getOperator()) {
+                        case PLUS -> bodyValue;
+                        case MINUS -> -bodyValue;
+                };
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealComparisonTerm.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealComparisonTerm.java
new file mode 100644
index 00000000..75d97adb
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealComparisonTerm.java
@@ -0,0 +1,35 @@
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.substitution.Substitution;
+import tools.refinery.store.query.term.ComparisonOperator;
+import tools.refinery.store.query.term.ComparisonTerm;
+import tools.refinery.store.query.term.Term;
+
+public class RealComparisonTerm extends ComparisonTerm<Double> {
+        public RealComparisonTerm(ComparisonOperator operator, Term<Double> left, Term<Double> right) {
+                super(operator, left, right);
+        }
+
+        @Override
+        public Class<Double> getOperandType() {
+                return Double.class;
+        }
+
+        @Override
+        public Term<Boolean> doSubstitute(Substitution substitution, Term<Double> substitutedLeft,
+                                                                          Term<Double> substitutedRight) {
+                return new RealComparisonTerm(getOperator(), substitutedLeft, substitutedRight);
+        }
+
+        @Override
+        protected Boolean doEvaluate(Double leftValue, Double rightValue) {
+                return switch (getOperator()) {
+                        case EQ -> leftValue.equals(rightValue);
+                        case NOT_EQ -> !leftValue.equals(rightValue);
+                        case LESS -> leftValue < rightValue;
+                        case LESS_EQ -> leftValue <= rightValue;
+                        case GREATER -> leftValue > rightValue;
+                        case GREATER_EQ -> leftValue >= rightValue;
+                };
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealExtremeValueAggregator.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealExtremeValueAggregator.java
new file mode 100644
index 00000000..23384530
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealExtremeValueAggregator.java
@@ -0,0 +1,17 @@
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.term.ExtremeValueAggregator;
+
+import java.util.Comparator;
+
+public final class RealExtremeValueAggregator {
+        public static final ExtremeValueAggregator<Double> MINIMUM = new ExtremeValueAggregator<>(Double.class,
+                        Double.POSITIVE_INFINITY);
+
+        public static final ExtremeValueAggregator<Double> MAXIMUM = new ExtremeValueAggregator<>(Double.class,
+                        Double.NEGATIVE_INFINITY, Comparator.reverseOrder());
+
+        private RealExtremeValueAggregator() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+}
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..d5888664
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealSumAggregator.java
@@ -0,0 +1,85 @@
+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 null;
+        }
+
+        @Override
+        public Class<Double> getInputType() {
+                return null;
+        }
+
+        @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..a8117842
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/term/real/RealTerms.java
@@ -0,0 +1,81 @@
+package tools.refinery.store.query.term.real;
+
+import tools.refinery.store.query.term.*;
+
+public final class RealTerms {
+        public static final Aggregator<Double, Double> REAL_SUM = RealSumAggregator.INSTANCE;
+        public static final Aggregator<Double, Double> REAL_MIN = RealExtremeValueAggregator.MINIMUM;
+        public static final Aggregator<Double, Double> REAL_MAX = RealExtremeValueAggregator.MAXIMUM;
+
+        private RealTerms() {
+                throw new IllegalArgumentException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static ConstantTerm<Double> constant(double value) {
+                return new ConstantTerm<>(Double.class, value);
+        }
+
+        public static RealArithmeticUnaryTerm plus(Term<Double> body) {
+                return new RealArithmeticUnaryTerm(ArithmeticUnaryOperator.PLUS, body);
+        }
+
+        public static RealArithmeticUnaryTerm minus(Term<Double> body) {
+                return new RealArithmeticUnaryTerm(ArithmeticUnaryOperator.MINUS, body);
+        }
+
+        public static RealArithmeticBinaryTerm add(Term<Double> left, Term<Double> right) {
+                return new RealArithmeticBinaryTerm(ArithmeticBinaryOperator.ADD, left, right);
+        }
+
+        public static RealArithmeticBinaryTerm sub(Term<Double> left, Term<Double> right) {
+                return new RealArithmeticBinaryTerm(ArithmeticBinaryOperator.SUB, left, right);
+        }
+
+        public static RealArithmeticBinaryTerm mul(Term<Double> left, Term<Double> right) {
+                return new RealArithmeticBinaryTerm(ArithmeticBinaryOperator.MUL, left, right);
+        }
+
+        public static RealArithmeticBinaryTerm div(Term<Double> left, Term<Double> right) {
+                return new RealArithmeticBinaryTerm(ArithmeticBinaryOperator.DIV, left, right);
+        }
+
+        public static RealArithmeticBinaryTerm pow(Term<Double> left, Term<Double> right) {
+                return new RealArithmeticBinaryTerm(ArithmeticBinaryOperator.POW, left, right);
+        }
+
+        public static RealArithmeticBinaryTerm min(Term<Double> left, Term<Double> right) {
+                return new RealArithmeticBinaryTerm(ArithmeticBinaryOperator.MIN, left, right);
+        }
+
+        public static RealArithmeticBinaryTerm max(Term<Double> left, Term<Double> right) {
+                return new RealArithmeticBinaryTerm(ArithmeticBinaryOperator.MAX, left, right);
+        }
+
+        public static RealComparisonTerm eq(Term<Double> left, Term<Double> right) {
+                return new RealComparisonTerm(ComparisonOperator.EQ, left, right);
+        }
+
+        public static RealComparisonTerm notEq(Term<Double> left, Term<Double> right) {
+                return new RealComparisonTerm(ComparisonOperator.NOT_EQ, left, right);
+        }
+
+        public static RealComparisonTerm less(Term<Double> left, Term<Double> right) {
+                return new RealComparisonTerm(ComparisonOperator.LESS, left, right);
+        }
+
+        public static RealComparisonTerm lessEq(Term<Double> left, Term<Double> right) {
+                return new RealComparisonTerm(ComparisonOperator.LESS_EQ, left, right);
+        }
+
+        public static RealComparisonTerm greater(Term<Double> left, Term<Double> right) {
+                return new RealComparisonTerm(ComparisonOperator.GREATER, left, right);
+        }
+
+        public static RealComparisonTerm greaterEq(Term<Double> left, Term<Double> right) {
+                return new RealComparisonTerm(ComparisonOperator.GREATER_EQ, left, right);
+        }
+
+        public static IntToRealTerm asReal(Term<Integer> body) {
+                return new IntToRealTerm(body);
+        }
+}
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..fb512d88
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/RestrictedValuation.java
@@ -0,0 +1,16 @@
+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..8e79663c
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/SubstitutedValuation.java
@@ -0,0 +1,11 @@
+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..3ba9a6b8
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/valuation/Valuation.java
@@ -0,0 +1,23 @@
+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.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));
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/AnyRelationView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/AnyRelationView.java
index 328cde3a..6ae410f2 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/AnyRelationView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/AnyRelationView.java
@@ -1,15 +1,17 @@
 package tools.refinery.store.query.view;
 
 import tools.refinery.store.model.Model;
-import tools.refinery.store.query.FunctionalDependency;
+import tools.refinery.store.query.dnf.FunctionalDependency;
 import tools.refinery.store.representation.AnySymbol;
-import tools.refinery.store.query.RelationLike;
+import tools.refinery.store.query.Constraint;
 
 import java.util.Set;
 
-public sealed interface AnyRelationView extends RelationLike permits RelationView {
+public sealed interface AnyRelationView extends Constraint permits RelationView {
         AnySymbol getSymbol();
 
+        String getViewName();
+
         default Set<FunctionalDependency<Integer>> getFunctionalDependencies() {
                 return Set.of();
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/FilteredRelationView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredRelationView.java
index 64c601bb..64c601bb 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/FilteredRelationView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FilteredRelationView.java
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/ForbiddenRelationView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/ForbiddenRelationView.java
new file mode 100644
index 00000000..050b9496
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/ForbiddenRelationView.java
@@ -0,0 +1,16 @@
+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 ForbiddenRelationView extends TuplePreservingRelationView<TruthValue> {
+        public ForbiddenRelationView(Symbol<TruthValue> symbol) {
+                super(symbol, "forbidden");
+        }
+
+        @Override
+        public boolean filter(Tuple key, TruthValue value) {
+                return !value.may();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/FunctionalRelationView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FunctionalRelationView.java
index 3d278a8b..7ec9e7ac 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/FunctionalRelationView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/FunctionalRelationView.java
@@ -1,22 +1,31 @@
 package tools.refinery.store.query.view;
 
 import tools.refinery.store.model.Model;
-import tools.refinery.store.query.FunctionalDependency;
+import tools.refinery.store.query.dnf.FunctionalDependency;
+import tools.refinery.store.query.term.DataSort;
+import tools.refinery.store.query.term.NodeSort;
+import tools.refinery.store.query.term.Sort;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.tuple.Tuple1;
 
+import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 public final class FunctionalRelationView<T> extends RelationView<T> {
+        private final T defaultValue;
+
         public FunctionalRelationView(Symbol<T> symbol, String name) {
                 super(symbol, name);
+                defaultValue = symbol.defaultValue();
         }
 
         public FunctionalRelationView(Symbol<T> symbol) {
                 super(symbol);
+                defaultValue = symbol.defaultValue();
         }
 
         @Override
@@ -37,7 +46,7 @@ public final class FunctionalRelationView<T> extends RelationView<T> {
 
         @Override
         public boolean filter(Tuple key, T value) {
-                return true;
+                return !Objects.equals(defaultValue, value);
         }
 
         @Override
@@ -68,4 +77,29 @@ public final class FunctionalRelationView<T> extends RelationView<T> {
         public int arity() {
                 return getSymbol().arity() + 1;
         }
+
+        @Override
+        public List<Sort> getSorts() {
+                var sorts = new Sort[arity()];
+                int valueIndex = sorts.length - 1;
+                for (int i = 0; i < valueIndex; i++) {
+                        sorts[i] = NodeSort.INSTANCE;
+                }
+                sorts[valueIndex] = new DataSort<>(getSymbol().valueType());
+                return List.of(sorts);
+        }
+
+        @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;
+                FunctionalRelationView<?> that = (FunctionalRelationView<?>) o;
+                return Objects.equals(defaultValue, that.defaultValue);
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(super.hashCode(), defaultValue);
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/KeyOnlyRelationView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/KeyOnlyRelationView.java
index e1b2e45b..e1b2e45b 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/KeyOnlyRelationView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/KeyOnlyRelationView.java
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MayRelationView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MayRelationView.java
new file mode 100644
index 00000000..a2a84b3c
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MayRelationView.java
@@ -0,0 +1,16 @@
+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 MayRelationView extends TuplePreservingRelationView<TruthValue> {
+        public MayRelationView(Symbol<TruthValue> symbol) {
+                super(symbol, "may");
+        }
+
+        @Override
+        public boolean filter(Tuple key, TruthValue value) {
+                return value.may();
+        }
+}
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MustRelationView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MustRelationView.java
new file mode 100644
index 00000000..72ac0ca3
--- /dev/null
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/MustRelationView.java
@@ -0,0 +1,16 @@
+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 MustRelationView extends TuplePreservingRelationView<TruthValue> {
+        public MustRelationView(Symbol<TruthValue> symbol) {
+                super(symbol, "must");
+        }
+
+        @Override
+        public boolean filter(Tuple key, TruthValue value) {
+                return value.must();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/RelationView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/RelationView.java
index bbec1e73..d7164b3b 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/RelationView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/RelationView.java
@@ -17,11 +17,11 @@ import java.util.UUID;
 public abstract non-sealed class RelationView<T> implements AnyRelationView {
         private final Symbol<T> symbol;
 
-        private final String name;
+        private final String viewName;
 
-        protected RelationView(Symbol<T> symbol, String name) {
+        protected RelationView(Symbol<T> symbol, String viewName) {
                 this.symbol = symbol;
-                this.name = name;
+                this.viewName = viewName;
         }
 
         protected RelationView(Symbol<T> representation) {
@@ -34,8 +34,13 @@ public abstract non-sealed class RelationView<T> implements AnyRelationView {
         }
 
         @Override
+        public String getViewName() {
+                return viewName;
+        }
+
+        @Override
         public String name() {
-                return symbol.name() + "#" + name;
+                return symbol.name() + "#" + viewName;
         }
 
         public abstract boolean filter(Tuple key, T value);
@@ -48,15 +53,25 @@ public abstract non-sealed class RelationView<T> implements AnyRelationView {
         }
 
         @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;
                 RelationView<?> that = (RelationView<?>) o;
-                return Objects.equals(symbol, that.symbol) && Objects.equals(name, that.name);
+                return Objects.equals(symbol, that.symbol) && Objects.equals(viewName, that.viewName);
         }
 
         @Override
         public int hashCode() {
-                return Objects.hash(symbol, name);
+                return Objects.hash(symbol, viewName);
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/RelationViewImplication.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/RelationViewImplication.java
index 2ba1fcc4..2ba1fcc4 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/RelationViewImplication.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/RelationViewImplication.java
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/view/TuplePreservingRelationView.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/TuplePreservingRelationView.java
index 8cc4986e..234b3a9a 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/view/TuplePreservingRelationView.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/view/TuplePreservingRelationView.java
@@ -1,10 +1,15 @@
 package tools.refinery.store.query.view;
 
 import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.NodeSort;
+import tools.refinery.store.query.term.Sort;
 import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.tuple.Tuple1;
 import tools.refinery.store.representation.Symbol;
 
+import java.util.Arrays;
+import java.util.List;
+
 public abstract class TuplePreservingRelationView<T> extends RelationView<T> {
         protected TuplePreservingRelationView(Symbol<T> symbol, String name) {
                 super(symbol, name);
@@ -38,7 +43,15 @@ public abstract class TuplePreservingRelationView<T> extends RelationView<T> {
                 return filter(key, value);
         }
 
+        @Override
         public int arity() {
                 return this.getSymbol().arity();
         }
+
+        @Override
+        public List<Sort> getSorts() {
+                var sorts = new Sort[arity()];
+                Arrays.fill(sorts, NodeSort.INSTANCE);
+                return List.of(sorts);
+        }
 }
diff --git a/subprojects/store-query/src/test/java/tools/refinery/store/query/DnfBuilderTest.java b/subprojects/store-query/src/test/java/tools/refinery/store/query/DnfBuilderTest.java
new file mode 100644
index 00000000..ceb46d6f
--- /dev/null
+++ b/subprojects/store-query/src/test/java/tools/refinery/store/query/DnfBuilderTest.java
@@ -0,0 +1,220 @@
+package tools.refinery.store.query;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.literal.BooleanLiteral;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.view.KeyOnlyRelationView;
+import tools.refinery.store.representation.Symbol;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static tools.refinery.store.query.literal.Literals.not;
+import static tools.refinery.store.query.tests.QueryMatchers.structurallyEqualTo;
+
+class DnfBuilderTest {
+        @Test
+        void eliminateTrueTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+
+                var actual = Dnf.builder()
+                                .parameters(p, q)
+                                .clause(BooleanLiteral.TRUE, friendView.call(p, q))
+                                .build();
+                var expected = Dnf.builder().parameters(p, q).clause(friendView.call(p, q)).build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+
+        @Test
+        void eliminateFalseTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+
+                var actual = Dnf.builder()
+                                .parameters(p, q)
+                                .clause(friendView.call(p, q))
+                                .clause(friendView.call(q, p), BooleanLiteral.FALSE)
+                                .build();
+                var expected = Dnf.builder().parameters(p, q).clause(friendView.call(p, q)).build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+
+        @Test
+        void alwaysTrueTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+
+                var actual = Dnf.builder()
+                                .parameters(p, q)
+                                .clause(friendView.call(p, q))
+                                .clause(BooleanLiteral.TRUE)
+                                .build();
+                var expected = Dnf.builder().parameters(p, q).clause().build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+
+        @Test
+        void alwaysFalseTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+
+                var actual = Dnf.builder()
+                                .parameters(p, q)
+                                .clause(friendView.call(p, q), BooleanLiteral.FALSE)
+                                .build();
+                var expected = Dnf.builder().parameters(p, q).build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+
+        @Test
+        void eliminateTrueDnfTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var trueDnf = Dnf.builder().parameter(p).clause().build();
+
+                var actual = Dnf.builder()
+                                .parameters(p, q)
+                                .clause(trueDnf.call(q), friendView.call(p, q))
+                                .build();
+                var expected = Dnf.builder().parameters(p, q).clause(friendView.call(p, q)).build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+
+        @Test
+        void eliminateFalseDnfTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var falseDnf = Dnf.builder().parameter(p).build();
+
+                var actual = Dnf.builder()
+                                .parameters(p, q)
+                                .clause(friendView.call(p, q))
+                                .clause(friendView.call(q, p), falseDnf.call(q))
+                                .build();
+                var expected = Dnf.builder().parameters(p, q).clause(friendView.call(p, q)).build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+
+        @Test
+        void alwaysTrueDnfTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var trueDnf = Dnf.builder().parameter(p).clause().build();
+
+                var actual = Dnf.builder()
+                                .parameters(p, q)
+                                .clause(friendView.call(p, q))
+                                .clause(trueDnf.call(q))
+                                .build();
+                var expected = Dnf.builder().parameters(p, q).clause().build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+
+        @Test
+        void alwaysFalseDnfTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var falseDnf = Dnf.builder().parameter(p).build();
+
+                var actual = Dnf.builder()
+                                .parameters(p, q)
+                                .clause(friendView.call(p, q), falseDnf.call(q))
+                                .build();
+                var expected = Dnf.builder().parameters(p, q).build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+
+        @Test
+        void eliminateNotFalseDnfTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var falseDnf = Dnf.builder().parameter(p).build();
+
+                var actual = Dnf.builder()
+                                .parameters(p, q)
+                                .clause(not(falseDnf.call(q)), friendView.call(p, q))
+                                .build();
+                var expected = Dnf.builder().parameters(p, q).clause(friendView.call(p, q)).build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+
+        @Test
+        void eliminateNotTrueDnfTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var trueDnf = Dnf.builder().parameter(p).clause().build();
+
+                var actual = Dnf.builder()
+                                .parameters(p, q)
+                                .clause(friendView.call(p, q))
+                                .clause(friendView.call(q, p), not(trueDnf.call(q)))
+                                .build();
+                var expected = Dnf.builder().parameters(p, q).clause(friendView.call(p, q)).build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+
+        @Test
+        void alwaysNotFalseDnfTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var falseDnf = Dnf.builder().parameter(p).build();
+
+                var actual = Dnf.builder()
+                                .parameters(p, q)
+                                .clause(friendView.call(p, q))
+                                .clause(not(falseDnf.call(q)))
+                                .build();
+                var expected = Dnf.builder().parameters(p, q).clause().build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+
+        @Test
+        void alwaysNotTrueDnfTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var trueDnf = Dnf.builder().parameter(p).clause().build();
+
+                var actual = Dnf.builder()
+                                .parameters(p, q)
+                                .clause(friendView.call(p, q), not(trueDnf.call(q)))
+                                .build();
+                var expected = Dnf.builder().parameters(p, q).build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+}
diff --git a/subprojects/store-query/src/test/java/tools/refinery/store/query/DnfToDefinitionStringTest.java b/subprojects/store-query/src/test/java/tools/refinery/store/query/DnfToDefinitionStringTest.java
new file mode 100644
index 00000000..9b469bb0
--- /dev/null
+++ b/subprojects/store-query/src/test/java/tools/refinery/store/query/DnfToDefinitionStringTest.java
@@ -0,0 +1,174 @@
+package tools.refinery.store.query;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.view.KeyOnlyRelationView;
+import tools.refinery.store.representation.Symbol;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static tools.refinery.store.query.literal.Literals.not;
+
+class DnfToDefinitionStringTest {
+        @Test
+        void noClausesTest() {
+                var p = Variable.of("p");
+                var dnf = Dnf.builder("Example").parameter(p).build();
+
+                assertThat(dnf.toDefinitionString(), is("""
+                                pred Example(p) <->
+                                    <no clauses>.
+                                """));
+        }
+
+        @Test
+        void noParametersTest() {
+                var dnf = Dnf.builder("Example").build();
+
+                assertThat(dnf.toDefinitionString(), is("""
+                                pred Example() <->
+                                    <no clauses>.
+                                """));
+        }
+
+        @Test
+        void emptyClauseTest() {
+                var p = Variable.of("p");
+                var dnf = Dnf.builder("Example").parameter(p).clause().build();
+
+                assertThat(dnf.toDefinitionString(), is("""
+                                pred Example(p) <->
+                                    <empty>.
+                                """));
+        }
+
+        @Test
+        void relationViewPositiveTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var dnf = Dnf.builder("Example").parameter(p).clause(friendView.call(p, q)).build();
+
+                assertThat(dnf.toDefinitionString(), is("""
+                                pred Example(p) <->
+                                    @RelationView("key") friend(p, q).
+                                """));
+        }
+
+        @Test
+        void relationViewNegativeTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var dnf = Dnf.builder("Example").parameter(p).clause(not(friendView.call(p, q))).build();
+
+                assertThat(dnf.toDefinitionString(), is("""
+                                pred Example(p) <->
+                                    !(@RelationView("key") friend(p, q)).
+                                """));
+        }
+
+        @Test
+        void relationViewTransitiveTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var dnf = Dnf.builder("Example").parameter(p).clause(friendView.callTransitive(p, q)).build();
+
+                assertThat(dnf.toDefinitionString(), is("""
+                                pred Example(p) <->
+                                    @RelationView("key") friend+(p, q).
+                                """));
+        }
+
+        @Test
+        void multipleParametersTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var dnf = Dnf.builder("Example").parameters(p, q).clause(friendView.call(p, q)).build();
+
+                assertThat(dnf.toDefinitionString(), is("""
+                                pred Example(p, q) <->
+                                    @RelationView("key") friend(p, q).
+                                """));
+        }
+
+        @Test
+        void multipleLiteralsTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var person = new Symbol<>("person", 1, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var dnf = Dnf.builder("Example")
+                                .parameter(p)
+                                .clause(
+                                                personView.call(p),
+                                                personView.call(q),
+                                                friendView.call(p, q)
+                                )
+                                .build();
+
+                assertThat(dnf.toDefinitionString(), is("""
+                                pred Example(p) <->
+                                    @RelationView("key") person(p),
+                                    @RelationView("key") person(q),
+                                    @RelationView("key") friend(p, q).
+                                """));
+        }
+
+        @Test
+        void multipleClausesTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var dnf = Dnf.builder("Example")
+                                .parameter(p)
+                                .clause(friendView.call(p, q))
+                                .clause(friendView.call(q, p))
+                                .build();
+
+                assertThat(dnf.toDefinitionString(), is("""
+                                pred Example(p) <->
+                                    @RelationView("key") friend(p, q)
+                                ;
+                                    @RelationView("key") friend(q, p).
+                                """));
+        }
+
+        @Test
+        void dnfTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var r = Variable.of("r");
+                var s = Variable.of("s");
+                var person = new Symbol<>("person", 1, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+                var friend = new Symbol<>("friend", 2, Boolean.class, false);
+                var friendView = new KeyOnlyRelationView<>(friend);
+                var called  = Dnf.builder("Called").parameters(r, s).clause(friendView.call(r, s)).build();
+                var dnf = Dnf.builder("Example")
+                                .parameter(p)
+                                .clause(
+                                                personView.call(p),
+                                                personView.call(q),
+                                                not(called.call(p, q))
+                                )
+                                .build();
+
+                assertThat(dnf.toDefinitionString(), is("""
+                                pred Example(p) <->
+                                    @RelationView("key") person(p),
+                                    @RelationView("key") person(q),
+                                    !(@Dnf Called(p, q)).
+                                """));
+        }
+}
diff --git a/subprojects/store-query/src/test/java/tools/refinery/store/query/tests/StructurallyEqualToTest.java b/subprojects/store-query/src/test/java/tools/refinery/store/query/tests/StructurallyEqualToTest.java
new file mode 100644
index 00000000..a61e2b65
--- /dev/null
+++ b/subprojects/store-query/src/test/java/tools/refinery/store/query/tests/StructurallyEqualToTest.java
@@ -0,0 +1,77 @@
+package tools.refinery.store.query.tests;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.view.KeyOnlyRelationView;
+import tools.refinery.store.representation.Symbol;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static tools.refinery.store.query.tests.QueryMatchers.structurallyEqualTo;
+
+class StructurallyEqualToTest {
+        @Test
+        void flatEqualsTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+
+                var expected = Dnf.builder("Expected").parameters(q).clause(personView.call(q)).build();
+                var actual = Dnf.builder("Actual").parameters(p).clause(personView.call(p)).build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+
+        @Test
+        void flatNotEqualsTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+
+                var expected = Dnf.builder("Expected").parameters(q).clause(personView.call(q)).build();
+                var actual = Dnf.builder("Actual").parameters(p).clause(personView.call(q)).build();
+
+                var assertion = structurallyEqualTo(expected);
+                assertThrows(AssertionError.class, () -> assertThat(actual, assertion));
+        }
+
+        @Test
+        void deepEqualsTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+
+                var expected = Dnf.builder("Expected").parameters(q).clause(
+                                Dnf.builder("Expected2").parameters(p).clause(personView.call(p)).build().call(q)
+                ).build();
+                var actual = Dnf.builder("Actual").parameters(q).clause(
+                                Dnf.builder("Actual2").parameters(p).clause(personView.call(p)).build().call(q)
+                ).build();
+
+                assertThat(actual, structurallyEqualTo(expected));
+        }
+
+        @Test
+        void deepNotEqualsTest() {
+                var p = Variable.of("p");
+                var q = Variable.of("q");
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var personView = new KeyOnlyRelationView<>(person);
+
+                var expected = Dnf.builder("Expected").parameters(q).clause(
+                                Dnf.builder("Expected2").parameters(p).clause(personView.call(p)).build().call(q)
+                ).build();
+                var actual = Dnf.builder("Actual").parameters(q).clause(
+                                Dnf.builder("Actual2").parameters(p).clause(personView.call(q)).build().call(q)
+                ).build();
+
+                var assertion = structurallyEqualTo(expected);
+                var error = assertThrows(AssertionError.class, () -> assertThat(actual, assertion));
+                assertThat(error.getMessage(), containsString(" called from Expected/1 "));
+        }
+}
diff --git a/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/MismatchDescribingDnfEqualityChecker.java b/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/MismatchDescribingDnfEqualityChecker.java
new file mode 100644
index 00000000..685957c9
--- /dev/null
+++ b/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/MismatchDescribingDnfEqualityChecker.java
@@ -0,0 +1,43 @@
+package tools.refinery.store.query.tests;
+
+import org.hamcrest.Description;
+import tools.refinery.store.query.equality.DeepDnfEqualityChecker;
+
+class MismatchDescribingDnfEqualityChecker extends DeepDnfEqualityChecker {
+        private final Description description;
+        private boolean described;
+
+        MismatchDescribingDnfEqualityChecker(Description description) {
+                this.description = description;
+        }
+
+        public boolean isDescribed() {
+                return described;
+        }
+
+        @Override
+        protected boolean doCheckEqual(Pair pair) {
+                boolean result = super.doCheckEqual(pair);
+                if (!result && !described) {
+                        describeMismatch(pair);
+                        // Only describe the first found (innermost) mismatch.
+                        described = true;
+                }
+                return result;
+        }
+
+        private void describeMismatch(Pair pair) {
+                var inProgress = getInProgress();
+                int size = inProgress.size();
+                if (size <= 1) {
+                        description.appendText("was ").appendText(pair.left().toDefinitionString());
+                        return;
+                }
+                var last = inProgress.get(size - 1);
+                description.appendText("expected ").appendText(last.right().toDefinitionString());
+                for (int i = size - 2; i >= 0; i--) {
+                        description.appendText(" called from ").appendText(inProgress.get(i).left().toString());
+                }
+                description.appendText(" was not structurally equal to ").appendText(last.right().toDefinitionString());
+        }
+}
diff --git a/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/QueryMatchers.java b/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/QueryMatchers.java
new file mode 100644
index 00000000..bf1c1b74
--- /dev/null
+++ b/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/QueryMatchers.java
@@ -0,0 +1,14 @@
+package tools.refinery.store.query.tests;
+
+import org.hamcrest.Matcher;
+import tools.refinery.store.query.dnf.Dnf;
+
+public final class QueryMatchers {
+        private QueryMatchers() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static Matcher<Dnf> structurallyEqualTo(Dnf expected) {
+                return new StructurallyEqualTo(expected);
+        }
+}
diff --git a/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/StructurallyEqualTo.java b/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/StructurallyEqualTo.java
new file mode 100644
index 00000000..a9a78f88
--- /dev/null
+++ b/subprojects/store-query/src/testFixtures/java/tools/refinery/store/query/tests/StructurallyEqualTo.java
@@ -0,0 +1,36 @@
+package tools.refinery.store.query.tests;
+
+import org.hamcrest.Description;
+import org.hamcrest.TypeSafeMatcher;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.equality.DeepDnfEqualityChecker;
+
+public class StructurallyEqualTo extends TypeSafeMatcher<Dnf> {
+        private final Dnf expected;
+
+        public StructurallyEqualTo(Dnf expected) {
+                this.expected = expected;
+        }
+
+        @Override
+        protected boolean matchesSafely(Dnf item) {
+                var checker = new DeepDnfEqualityChecker();
+                return checker.dnfEqual(expected, item);
+        }
+
+        @Override
+        protected void describeMismatchSafely(Dnf item, Description mismatchDescription) {
+                var describingChecker = new MismatchDescribingDnfEqualityChecker(mismatchDescription);
+                if (describingChecker.dnfEqual(expected, item)) {
+                        throw new IllegalStateException("Mismatched Dnf was matching on repeated comparison");
+                }
+                if (!describingChecker.isDescribed()) {
+                        super.describeMismatchSafely(item, mismatchDescription);
+                }
+        }
+
+        @Override
+        public void describeTo(Description description) {
+                description.appendText("structurally equal to ").appendText(expected.toDefinitionString());
+        }
+}
diff --git a/subprojects/store-reasoning/build.gradle b/subprojects/store-reasoning/build.gradle
new file mode 100644
index 00000000..cb440d9f
--- /dev/null
+++ b/subprojects/store-reasoning/build.gradle
@@ -0,0 +1,7 @@
+plugins {
+        id 'refinery-java-library'
+}
+
+dependencies {
+        api project(':refinery-store-query')
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/AnyPartialInterpretation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/AnyPartialInterpretation.java
new file mode 100644
index 00000000..ebe82c8b
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/AnyPartialInterpretation.java
@@ -0,0 +1,13 @@
+package tools.refinery.store.reasoning;
+
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+
+public sealed interface AnyPartialInterpretation permits PartialInterpretation {
+        ReasoningAdapter getAdapter();
+
+        AnyPartialSymbol getPartialSymbol();
+
+        int countUnfinished();
+
+        int countErrors();
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/MergeResult.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/MergeResult.java
new file mode 100644
index 00000000..0d51598b
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/MergeResult.java
@@ -0,0 +1,15 @@
+package tools.refinery.store.reasoning;
+
+public enum MergeResult {
+        UNCHANGED,
+        REFINED,
+        REJECTED;
+
+        public MergeResult andAlso(MergeResult other) {
+                return switch (this) {
+                        case UNCHANGED -> other;
+                        case REFINED -> other == REJECTED ? REJECTED : REFINED;
+                        case REJECTED -> REJECTED;
+                };
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/PartialInterpretation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/PartialInterpretation.java
new file mode 100644
index 00000000..4f195e97
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/PartialInterpretation.java
@@ -0,0 +1,20 @@
+package tools.refinery.store.reasoning;
+
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.tuple.Tuple;
+
+public non-sealed interface PartialInterpretation<A, C> extends AnyPartialInterpretation {
+        @Override
+        PartialSymbol<A, C> getPartialSymbol();
+
+        A get(Tuple key);
+
+        Cursor<Tuple, A> getAll();
+
+        MergeResult merge(Tuple key, A value);
+
+        C getConcrete(Tuple key);
+
+        Cursor<Tuple, C> getAllConcrete();
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/Reasoning.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/Reasoning.java
new file mode 100644
index 00000000..d7d0a999
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/Reasoning.java
@@ -0,0 +1,24 @@
+package tools.refinery.store.reasoning;
+
+import tools.refinery.store.reasoning.internal.ReasoningBuilderImpl;
+import tools.refinery.store.adapter.ModelAdapterBuilderFactory;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+
+public final class Reasoning extends ModelAdapterBuilderFactory<ReasoningAdapter,
+                ReasoningStoreAdapter, ReasoningBuilder> {
+        public static final Reasoning ADAPTER = new Reasoning();
+
+        public static final PartialRelation EXISTS = new PartialRelation("exists", 1);
+
+        public static final PartialRelation EQUALS = new PartialRelation("equals", 1);
+
+        private Reasoning() {
+                super(ReasoningAdapter.class, ReasoningStoreAdapter.class, ReasoningBuilder.class);
+        }
+
+        @Override
+        public ReasoningBuilder createBuilder(ModelStoreBuilder storeBuilder) {
+                return new ReasoningBuilderImpl(storeBuilder);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java
new file mode 100644
index 00000000..de039dd9
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningAdapter.java
@@ -0,0 +1,22 @@
+package tools.refinery.store.reasoning;
+
+import tools.refinery.store.adapter.ModelAdapter;
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.ResultSet;
+
+public interface ReasoningAdapter extends ModelAdapter {
+        @Override
+        ReasoningStoreAdapter getStoreAdapter();
+
+        default AnyPartialInterpretation getPartialInterpretation(AnyPartialSymbol partialSymbol) {
+                // Cast to disambiguate overloads.
+                var typedPartialSymbol = (PartialSymbol<?, ?>) partialSymbol;
+                return getPartialInterpretation(typedPartialSymbol);
+        }
+
+        <A, C> PartialInterpretation<A, C> getPartialInterpretation(PartialSymbol<A, C> partialSymbol);
+
+        ResultSet getLiftedResultSet(Dnf query);
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningBuilder.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningBuilder.java
new file mode 100644
index 00000000..4030d296
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningBuilder.java
@@ -0,0 +1,28 @@
+package tools.refinery.store.reasoning;
+
+import tools.refinery.store.adapter.ModelAdapterBuilder;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.reasoning.literal.Modality;
+import tools.refinery.store.query.dnf.Dnf;
+
+import java.util.Collection;
+import java.util.List;
+
+@SuppressWarnings("UnusedReturnValue")
+public interface ReasoningBuilder extends ModelAdapterBuilder {
+        default ReasoningBuilder liftedQueries(Dnf... liftedQueries) {
+                return liftedQueries(List.of(liftedQueries));
+        }
+
+        default ReasoningBuilder liftedQueries(Collection<Dnf> liftedQueries) {
+                liftedQueries.forEach(this::liftedQuery);
+                return this;
+        }
+
+        ReasoningBuilder liftedQuery(Dnf liftedQuery);
+
+        Dnf lift(Modality modality, Dnf query);
+
+        @Override
+        ReasoningStoreAdapter createStoreAdapter(ModelStore store);
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java
new file mode 100644
index 00000000..f6a6e414
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/ReasoningStoreAdapter.java
@@ -0,0 +1,17 @@
+package tools.refinery.store.reasoning;
+
+import tools.refinery.store.adapter.ModelStoreAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+import tools.refinery.store.query.dnf.Dnf;
+
+import java.util.Collection;
+
+public interface ReasoningStoreAdapter extends ModelStoreAdapter {
+        Collection<AnyPartialSymbol> getPartialSymbols();
+
+        Collection<Dnf> getLiftedQueries();
+
+        @Override
+        ReasoningAdapter createModelAdapter(Model model);
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
new file mode 100644
index 00000000..0acf0d49
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningAdapterImpl.java
@@ -0,0 +1,38 @@
+package tools.refinery.store.reasoning.internal;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.PartialInterpretation;
+import tools.refinery.store.reasoning.representation.PartialSymbol;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.ResultSet;
+
+public class ReasoningAdapterImpl implements ReasoningAdapter {
+        private final Model model;
+        private final ReasoningStoreAdapterImpl storeAdapter;
+
+        ReasoningAdapterImpl(Model model, ReasoningStoreAdapterImpl storeAdapter) {
+                this.model = model;
+                this.storeAdapter = storeAdapter;
+        }
+
+        @Override
+        public Model getModel() {
+                return model;
+        }
+
+        @Override
+        public ReasoningStoreAdapterImpl getStoreAdapter() {
+                return storeAdapter;
+        }
+
+        @Override
+        public <A, C> PartialInterpretation<A, C> getPartialInterpretation(PartialSymbol<A, C> partialSymbol) {
+                return null;
+        }
+
+        @Override
+        public ResultSet getLiftedResultSet(Dnf query) {
+                return null;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningBuilderImpl.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningBuilderImpl.java
new file mode 100644
index 00000000..e11b14bf
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningBuilderImpl.java
@@ -0,0 +1,29 @@
+package tools.refinery.store.reasoning.internal;
+
+import tools.refinery.store.adapter.AbstractModelAdapterBuilder;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.reasoning.ReasoningBuilder;
+import tools.refinery.store.reasoning.literal.Modality;
+import tools.refinery.store.query.dnf.Dnf;
+
+public class ReasoningBuilderImpl extends AbstractModelAdapterBuilder implements ReasoningBuilder {
+        public ReasoningBuilderImpl(ModelStoreBuilder storeBuilder) {
+                super(storeBuilder);
+        }
+
+        @Override
+        public ReasoningBuilder liftedQuery(Dnf liftedQuery) {
+                return null;
+        }
+
+        @Override
+        public Dnf lift(Modality modality, Dnf query) {
+                return null;
+        }
+
+        @Override
+        public ReasoningStoreAdapterImpl createStoreAdapter(ModelStore store) {
+                return null;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java
new file mode 100644
index 00000000..ac06e68b
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/internal/ReasoningStoreAdapterImpl.java
@@ -0,0 +1,37 @@
+package tools.refinery.store.reasoning.internal;
+
+import tools.refinery.store.reasoning.ReasoningStoreAdapter;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+import tools.refinery.store.query.dnf.Dnf;
+
+import java.util.Collection;
+
+public class ReasoningStoreAdapterImpl implements ReasoningStoreAdapter {
+        private final ModelStore store;
+
+        ReasoningStoreAdapterImpl(ModelStore store) {
+                this.store = store;
+        }
+
+        @Override
+        public ModelStore getStore() {
+                return store;
+        }
+
+        @Override
+        public Collection<AnyPartialSymbol> getPartialSymbols() {
+                return null;
+        }
+
+        @Override
+        public Collection<Dnf> getLiftedQueries() {
+                return null;
+        }
+
+        @Override
+        public ReasoningAdapterImpl createModelAdapter(Model model) {
+                return new ReasoningAdapterImpl(model, this);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/DnfLifter.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/DnfLifter.java
new file mode 100644
index 00000000..2b0e0f08
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/DnfLifter.java
@@ -0,0 +1,116 @@
+package tools.refinery.store.reasoning.lifting;
+
+import org.jetbrains.annotations.Nullable;
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.query.dnf.DnfBuilder;
+import tools.refinery.store.query.dnf.DnfClause;
+import tools.refinery.store.query.literal.CallLiteral;
+import tools.refinery.store.query.literal.CallPolarity;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.term.DataVariable;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.reasoning.Reasoning;
+import tools.refinery.store.reasoning.literal.ModalConstraint;
+import tools.refinery.store.reasoning.literal.Modality;
+import tools.refinery.store.reasoning.literal.PartialLiterals;
+import tools.refinery.store.util.CycleDetectingMapper;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
+public class DnfLifter {
+        private final CycleDetectingMapper<ModalDnf, Dnf> mapper = new CycleDetectingMapper<>(ModalDnf::toString,
+                        this::doLift);
+
+        public Dnf lift(Modality modality, Dnf query) {
+                return mapper.map(new ModalDnf(modality, query));
+        }
+
+        private Dnf doLift(ModalDnf modalDnf) {
+                var modality = modalDnf.modality();
+                var dnf = modalDnf.dnf();
+                var builder = Dnf.builder();
+                builder.parameters(dnf.getParameters());
+                boolean changed = false;
+                for (var clause : dnf.getClauses()) {
+                        if (liftClause(modality, clause, builder)) {
+                                changed = true;
+                        }
+                }
+                if (changed) {
+                        return builder.build();
+                }
+                return dnf;
+        }
+
+        private boolean liftClause(Modality modality, DnfClause clause, DnfBuilder builder) {
+                boolean changed = false;
+                var quantifiedVariables = new HashSet<>(clause.boundVariables()
+                                .stream()
+                                .filter(DataVariable.class::isInstance)
+                                .toList());
+                var literals = clause.literals();
+                var liftedLiterals = new ArrayList<Literal>(literals.size());
+                for (var literal : literals) {
+                        Literal liftedLiteral = liftLiteral(modality, literal);
+                        if (liftedLiteral == null) {
+                                liftedLiteral = literal;
+                        } else {
+                                changed = true;
+                        }
+                        liftedLiterals.add(liftedLiteral);
+                        var variable = isExistsLiteralForVariable(modality, liftedLiteral);
+                        if (variable != null) {
+                                // If we already quantify over the existence of the variable with the expected modality,
+                                // we don't need to insert quantification manually.
+                                quantifiedVariables.remove(variable);
+                        }
+                }
+                for (var quantifiedVariable : quantifiedVariables) {
+                        // Quantify over data variables that are not already quantified with the expected modality.
+                        liftedLiterals.add(new CallLiteral(CallPolarity.POSITIVE, new ModalConstraint(modality, Reasoning.EXISTS),
+                                        List.of(quantifiedVariable)));
+                }
+                builder.clause(liftedLiterals);
+                return changed || !quantifiedVariables.isEmpty();
+        }
+
+        @Nullable
+        private Variable isExistsLiteralForVariable(Modality modality, Literal literal) {
+                if (literal instanceof CallLiteral callLiteral &&
+                                callLiteral.getPolarity() == CallPolarity.POSITIVE &&
+                                callLiteral.getTarget() instanceof ModalConstraint modalConstraint &&
+                                modalConstraint.modality() == modality &&
+                                modalConstraint.constraint().equals(Reasoning.EXISTS)) {
+                        return callLiteral.getArguments().get(0);
+                }
+                return null;
+        }
+
+        @Nullable
+        private Literal liftLiteral(Modality modality, Literal literal) {
+                if (!(literal instanceof CallLiteral callLiteral)) {
+                        return null;
+                }
+                var target = callLiteral.getTarget();
+                if (target instanceof ModalConstraint modalTarget) {
+                        var actualTarget = modalTarget.constraint();
+                        if (actualTarget instanceof Dnf dnf) {
+                                var targetModality = modalTarget.modality();
+                                var liftedTarget = lift(targetModality, dnf);
+                                return new CallLiteral(callLiteral.getPolarity(), liftedTarget, callLiteral.getArguments());
+                        }
+                        // No more lifting to be done, pass any modal call to a partial symbol through.
+                        return null;
+                } else if (target instanceof Dnf dnf) {
+                        var polarity = callLiteral.getPolarity();
+                        var liftedTarget = lift(modality.commute(polarity), dnf);
+                        // Use == instead of equals(), because lift will return the same object by reference is there are no
+                        // changes made during lifting.
+                        return liftedTarget == target ? null : new CallLiteral(polarity, liftedTarget, callLiteral.getArguments());
+                } else {
+                        return PartialLiterals.addModality(callLiteral, modality);
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/ModalDnf.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/ModalDnf.java
new file mode 100644
index 00000000..ec381bb8
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/lifting/ModalDnf.java
@@ -0,0 +1,11 @@
+package tools.refinery.store.reasoning.lifting;
+
+import tools.refinery.store.query.dnf.Dnf;
+import tools.refinery.store.reasoning.literal.Modality;
+
+record ModalDnf(Modality modality, Dnf dnf) {
+        @Override
+        public String toString() {
+                return "%s %s".formatted(modality, dnf.name());
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java
new file mode 100644
index 00000000..2fbb4607
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/ModalConstraint.java
@@ -0,0 +1,46 @@
+package tools.refinery.store.reasoning.literal;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.literal.LiteralReduction;
+import tools.refinery.store.query.term.Sort;
+
+import java.util.List;
+
+public record ModalConstraint(Modality modality, Constraint constraint) implements Constraint {
+        private static final String FORMAT = "%s %s";
+
+        @Override
+        public String name() {
+                return FORMAT.formatted(modality, constraint.name());
+        }
+
+        @Override
+        public List<Sort> getSorts() {
+                return constraint.getSorts();
+        }
+
+        @Override
+        public LiteralReduction getReduction() {
+                return constraint.getReduction();
+        }
+
+        @Override
+        public boolean equals(LiteralEqualityHelper helper, Constraint other) {
+                if (getClass() != other.getClass()) {
+                        return false;
+                }
+                var otherModalConstraint = (ModalConstraint) other;
+                return modality == otherModalConstraint.modality && constraint.equals(helper, otherModalConstraint.constraint);
+        }
+
+        @Override
+        public String toReferenceString() {
+                return FORMAT.formatted(modality, constraint.toReferenceString());
+        }
+
+        @Override
+        public String toString() {
+                return FORMAT.formatted(modality, constraint);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/Modality.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/Modality.java
index e389f563..f0cb59de 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/Modality.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/Modality.java
@@ -1,4 +1,6 @@
-package tools.refinery.store.query.atom;
+package tools.refinery.store.reasoning.literal;
+
+import tools.refinery.store.query.literal.CallPolarity;
 
 import java.util.Locale;
 
@@ -15,6 +17,13 @@ public enum Modality {
                 };
         }
 
+        public Modality commute(CallPolarity polarity) {
+                if (polarity.isPositive()) {
+                        return this;
+                }
+                return this.negate();
+        }
+
         @Override
         public String toString() {
                 return name().toLowerCase(Locale.ROOT);
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java
new file mode 100644
index 00000000..f991f87f
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/literal/PartialLiterals.java
@@ -0,0 +1,31 @@
+package tools.refinery.store.reasoning.literal;
+
+import tools.refinery.store.query.literal.CallLiteral;
+
+public final class PartialLiterals {
+        private PartialLiterals() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static CallLiteral may(CallLiteral literal) {
+                return addModality(literal, Modality.MAY);
+        }
+
+        public static CallLiteral must(CallLiteral literal) {
+                return addModality(literal, Modality.MUST);
+        }
+
+        public static CallLiteral current(CallLiteral literal) {
+                return addModality(literal, Modality.CURRENT);
+        }
+
+        public static CallLiteral addModality(CallLiteral literal, Modality modality) {
+                var target = literal.getTarget();
+                if (target instanceof ModalConstraint) {
+                        throw new IllegalArgumentException("Literal %s already has modality".formatted(literal));
+                }
+                var polarity = literal.getPolarity();
+                var modalTarget = new ModalConstraint(modality.commute(polarity), target);
+                return new CallLiteral(polarity, modalTarget, literal.getArguments());
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/AnyPartialFunction.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/AnyPartialFunction.java
new file mode 100644
index 00000000..e74cd58b
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/AnyPartialFunction.java
@@ -0,0 +1,4 @@
+package tools.refinery.store.reasoning.representation;
+
+public sealed interface AnyPartialFunction extends AnyPartialSymbol permits PartialFunction {
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/AnyPartialSymbol.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/AnyPartialSymbol.java
new file mode 100644
index 00000000..6ff5031b
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/AnyPartialSymbol.java
@@ -0,0 +1,11 @@
+package tools.refinery.store.reasoning.representation;
+
+import tools.refinery.store.representation.AnyAbstractDomain;
+
+public sealed interface AnyPartialSymbol permits AnyPartialFunction, PartialSymbol {
+        String name();
+
+        int arity();
+
+        AnyAbstractDomain abstractDomain();
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialFunction.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialFunction.java
new file mode 100644
index 00000000..59eeeefe
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialFunction.java
@@ -0,0 +1,32 @@
+package tools.refinery.store.reasoning.representation;
+
+import tools.refinery.store.representation.AbstractDomain;
+
+public record PartialFunction<A, C>(String name, int arity, AbstractDomain<A, C> abstractDomain)
+                implements AnyPartialFunction, PartialSymbol<A, C> {
+        @Override
+        public A defaultValue() {
+                return null;
+        }
+
+        @Override
+        public C defaultConcreteValue() {
+                return null;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                return this == o;
+        }
+
+        @Override
+        public int hashCode() {
+                // Compare by identity to make hash table lookups more efficient.
+                return System.identityHashCode(this);
+        }
+
+        @Override
+        public String toString() {
+                return "%s/%d".formatted(name, arity);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialRelation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialRelation.java
new file mode 100644
index 00000000..9bae53a9
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialRelation.java
@@ -0,0 +1,56 @@
+package tools.refinery.store.reasoning.representation;
+
+import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.term.NodeSort;
+import tools.refinery.store.query.term.Sort;
+import tools.refinery.store.representation.AbstractDomain;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.representation.TruthValueDomain;
+
+import java.util.Arrays;
+import java.util.List;
+
+public record PartialRelation(String name, int arity) implements PartialSymbol<TruthValue, Boolean>, Constraint {
+        @Override
+        public AbstractDomain<TruthValue, Boolean> abstractDomain() {
+                return TruthValueDomain.INSTANCE;
+        }
+
+        @Override
+        public TruthValue defaultValue() {
+                return TruthValue.FALSE;
+        }
+
+        @Override
+        public Boolean defaultConcreteValue() {
+                return false;
+        }
+
+        @Override
+        public List<Sort> getSorts() {
+                var sorts = new Sort[arity()];
+                Arrays.fill(sorts, NodeSort.INSTANCE);
+                return List.of(sorts);
+        }
+
+        @Override
+        public String toReferenceString() {
+                return name;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                return this == o;
+        }
+
+        @Override
+        public int hashCode() {
+                // Compare by identity to make hash table lookups more efficient.
+                return System.identityHashCode(this);
+        }
+
+        @Override
+        public String toString() {
+                return "%s/%d".formatted(name, arity);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialSymbol.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialSymbol.java
new file mode 100644
index 00000000..1af11f2e
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/representation/PartialSymbol.java
@@ -0,0 +1,12 @@
+package tools.refinery.store.reasoning.representation;
+
+import tools.refinery.store.representation.AbstractDomain;
+
+public sealed interface PartialSymbol<A, C> extends AnyPartialSymbol permits PartialFunction, PartialRelation {
+        @Override
+        AbstractDomain<A, C> abstractDomain();
+
+        A defaultValue();
+
+        C defaultConcreteValue();
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RelationRefinementAction.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RelationRefinementAction.java
new file mode 100644
index 00000000..e8ed05a3
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RelationRefinementAction.java
@@ -0,0 +1,36 @@
+package tools.refinery.store.reasoning.rule;
+
+import tools.refinery.store.reasoning.Reasoning;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.List;
+
+public record RelationRefinementAction(PartialRelation target, List<Variable> arguments, TruthValue value)
+                implements RuleAction {
+        public RelationRefinementAction {
+                if (arguments.size() != target.arity()) {
+                        throw new IllegalArgumentException("%s needs %d parameters, but got %s".formatted(target.name(),
+                                        target.arity(), arguments.size()));
+                }
+                if (value == TruthValue.UNKNOWN) {
+                        throw new IllegalArgumentException("Refining with UNKNOWN has no effect");
+                }
+        }
+
+        @Override
+        public RuleActionExecutor createExecutor(int[] argumentIndices, Model model) {
+                var targetInterpretation = model.getAdapter(Reasoning.ADAPTER).getPartialInterpretation(target);
+                return activationTuple -> {
+                        int arity = argumentIndices.length;
+                        var arguments = new int[arity];
+                        for (int i = 0; i < arity; i++) {
+                                arguments[i] = activationTuple.get(argumentIndices[i]);
+                        }
+                        return targetInterpretation.merge(Tuple.of(arguments), value);
+                };
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/Rule.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/Rule.java
new file mode 100644
index 00000000..c7b16d47
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/Rule.java
@@ -0,0 +1,38 @@
+package tools.refinery.store.reasoning.rule;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.dnf.Dnf;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
+public record Rule(Dnf precondition, List<RuleAction> actions) {
+        public Rule {
+                var parameterSet = new HashSet<>(precondition.getParameters());
+                for (var action : actions) {
+                        for (var argument : action.arguments()) {
+                                if (!parameterSet.contains(argument)) {
+                                        throw new IllegalArgumentException(
+                                                        "Argument %s of action %s does not appear in the parameter list %s of %s"
+                                                                        .formatted(argument, action, precondition.getParameters(), precondition.name()));
+                                }
+                        }
+                }
+        }
+
+        public RuleExecutor createExecutor(Model model) {
+                var parameters = precondition.getParameters();
+                var actionExecutors = new ArrayList<RuleActionExecutor>(actions.size());
+                for (var action : actions) {
+                        var arguments = action.arguments();
+                        int arity = arguments.size();
+                        var argumentIndices = new int[arity];
+                        for (int i = 0; i < arity; i++) {
+                                argumentIndices[i] = parameters.indexOf(arguments.get(i));
+                        }
+                        actionExecutors.add(action.createExecutor(argumentIndices, model));
+                }
+                return new RuleExecutor(this, model, actionExecutors);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RuleAction.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RuleAction.java
new file mode 100644
index 00000000..4753b8bc
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RuleAction.java
@@ -0,0 +1,12 @@
+package tools.refinery.store.reasoning.rule;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.Variable;
+
+import java.util.List;
+
+public interface RuleAction {
+        List<Variable> arguments();
+
+        RuleActionExecutor createExecutor(int[] argumentIndices, Model model);
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RuleActionExecutor.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RuleActionExecutor.java
new file mode 100644
index 00000000..80bfa6f8
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RuleActionExecutor.java
@@ -0,0 +1,9 @@
+package tools.refinery.store.reasoning.rule;
+
+import tools.refinery.store.reasoning.MergeResult;
+import tools.refinery.store.tuple.TupleLike;
+
+@FunctionalInterface
+public interface RuleActionExecutor {
+        MergeResult execute(TupleLike activationTuple);
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RuleExecutor.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RuleExecutor.java
new file mode 100644
index 00000000..1e5322b4
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/rule/RuleExecutor.java
@@ -0,0 +1,34 @@
+package tools.refinery.store.reasoning.rule;
+
+import tools.refinery.store.reasoning.MergeResult;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.tuple.TupleLike;
+
+import java.util.List;
+
+public final class RuleExecutor {
+        private final Rule rule;
+        private final Model model;
+        private final List<RuleActionExecutor> actionExecutors;
+
+        RuleExecutor(Rule rule, Model model, List<RuleActionExecutor> actionExecutors) {
+                this.rule = rule;
+                this.model = model;
+                this.actionExecutors = actionExecutors;
+        }
+
+        public Rule getRule() {
+                return rule;
+        }
+
+        public Model getModel() {
+                return model;
+        }
+        public MergeResult execute(TupleLike activationTuple) {
+                MergeResult mergeResult = MergeResult.UNCHANGED;
+                for (var actionExecutor : actionExecutors) {
+                        mergeResult = mergeResult.andAlso(actionExecutor.execute(activationTuple));
+                }
+                return mergeResult;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java
new file mode 100644
index 00000000..90633495
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java
@@ -0,0 +1,14 @@
+package tools.refinery.store.reasoning.seed;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.tuple.Tuple;
+
+public interface Seed<T> {
+        int arity();
+
+        T reducedValue();
+
+        T get(Tuple key);
+
+        Cursor<Tuple, T> getCursor(T defaultValue, int nodeCount);
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/UniformSeed.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/UniformSeed.java
new file mode 100644
index 00000000..a030f6ea
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/UniformSeed.java
@@ -0,0 +1,22 @@
+package tools.refinery.store.reasoning.seed;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.tuple.Tuple;
+
+public record UniformSeed<T>(int arity, T reducedValue) implements Seed<T> {
+        public UniformSeed {
+                if (arity < 0) {
+                        throw new IllegalArgumentException("Arity must not be negative");
+                }
+        }
+
+        @Override
+        public T get(Tuple key) {
+                return reducedValue;
+        }
+
+        @Override
+        public Cursor<Tuple, T> getCursor(T defaultValue, int nodeCount) {
+                return null;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/Advice.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/Advice.java
new file mode 100644
index 00000000..5cdfedf7
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/Advice.java
@@ -0,0 +1,159 @@
+package tools.refinery.store.reasoning.translator;
+
+import tools.refinery.store.reasoning.representation.AnyPartialSymbol;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.query.substitution.Substitutions;
+
+import java.util.*;
+
+public final class Advice {
+        private final AnyPartialSymbol source;
+        private final PartialRelation target;
+        private final AdviceSlot slot;
+        private final boolean mandatory;
+        private final List<Variable> parameters;
+        private final List<Literal> literals;
+        private boolean processed;
+
+        public Advice(AnyPartialSymbol source, PartialRelation target, AdviceSlot slot, boolean mandatory, List<Variable> parameters, List<Literal> literals) {
+                if (mandatory && !slot.isMonotonic()) {
+                        throw new IllegalArgumentException("Only monotonic advice can be mandatory");
+                }
+                this.source = source;
+                this.target = target;
+                this.slot = slot;
+                this.mandatory = mandatory;
+                checkArity(parameters);
+                this.parameters = parameters;
+                this.literals = literals;
+        }
+
+        public AnyPartialSymbol source() {
+                return source;
+        }
+
+        public PartialRelation target() {
+                return target;
+        }
+
+        public AdviceSlot slot() {
+                return slot;
+        }
+
+        public boolean mandatory() {
+                return mandatory;
+        }
+
+        public List<Variable> parameters() {
+                return parameters;
+        }
+
+        public List<Literal> literals() {
+                return literals;
+        }
+
+        public boolean processed() {
+                return processed;
+        }
+
+        public List<Literal> substitute(List<Variable> substituteParameters) {
+                checkArity(substituteParameters);
+                markProcessed();
+                int arity = parameters.size();
+                var variableMap = new HashMap<Variable, Variable>(arity);
+                for (int i = 0; i < arity; i++) {
+                        variableMap.put(parameters.get(i), substituteParameters.get(i));
+                }
+                // Use a renewing substitution to remove any non-parameter variables and avoid clashed between variables
+                // coming from different advice in the same clause.
+                var substitution = Substitutions.renewing(variableMap);
+                return literals.stream().map(literal -> literal.substitute(substitution)).toList();
+        }
+
+        private void markProcessed() {
+                processed = true;
+        }
+
+        public void checkProcessed() {
+                if (mandatory && !processed) {
+                        throw new IllegalStateException("Mandatory advice %s was not processed".formatted(this));
+                }
+        }
+
+        private void checkArity(List<Variable> toCheck) {
+                if (toCheck.size() != target.arity()) {
+                        throw new IllegalArgumentException("%s needs %d parameters, but got %s".formatted(target.name(),
+                                        target.arity(), parameters.size()));
+                }
+        }
+
+        public static Builder builderFor(AnyPartialSymbol source, PartialRelation target, AdviceSlot slot) {
+                return new Builder(source, target, slot);
+        }
+
+
+        @Override
+        public String toString() {
+                return "Advice[source=%s, target=%s, slot=%s, mandatory=%s, parameters=%s, literals=%s]".formatted(source,
+                                target, slot, mandatory, parameters, literals);
+        }
+
+        public static class Builder {
+                private final AnyPartialSymbol source;
+                private final PartialRelation target;
+                private final AdviceSlot slot;
+                private boolean mandatory;
+                private final List<Variable> parameters = new ArrayList<>();
+                private final List<Literal> literals = new ArrayList<>();
+
+                private Builder(AnyPartialSymbol source, PartialRelation target, AdviceSlot slot) {
+                        this.source = source;
+                        this.target = target;
+                        this.slot = slot;
+                }
+
+                public Builder mandatory(boolean mandatory) {
+                        this.mandatory = mandatory;
+                        return this;
+                }
+
+                public Builder mandatory() {
+                        return mandatory(false);
+                }
+
+                public Builder parameters(List<Variable> variables) {
+                        parameters.addAll(variables);
+                        return this;
+                }
+
+                public Builder parameters(Variable... variables) {
+                        return parameters(List.of(variables));
+                }
+
+                public Builder parameter(Variable variable) {
+                        parameters.add(variable);
+                        return this;
+                }
+
+                public Builder literals(Collection<Literal> literals) {
+                        this.literals.addAll(literals);
+                        return this;
+                }
+
+                public Builder literals(Literal... literals) {
+                        return literals(List.of(literals));
+                }
+
+                public Builder literal(Literal literal) {
+                        literals.add(literal);
+                        return this;
+                }
+
+                public Advice build() {
+                        return new Advice(source, target, slot, mandatory, Collections.unmodifiableList(parameters),
+                                        Collections.unmodifiableList(literals));
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/AdviceSlot.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/AdviceSlot.java
new file mode 100644
index 00000000..f3bd9c5e
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/AdviceSlot.java
@@ -0,0 +1,25 @@
+package tools.refinery.store.reasoning.translator;
+
+import tools.refinery.store.representation.TruthValue;
+
+public enum AdviceSlot {
+        EXTEND_MUST(true),
+
+        RESTRICT_MAY(true),
+
+        /**
+         * Same as {@link #RESTRICT_MAY}, but only active if the value of the relation is not {@link TruthValue#TRUE} or
+         * {@link TruthValue#ERROR}.
+         */
+        RESTRICT_NEW(false);
+
+        private final boolean monotonic;
+
+        AdviceSlot(boolean monotonic) {
+                this.monotonic = monotonic;
+        }
+
+        public boolean isMonotonic() {
+                return monotonic;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslatedRelation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslatedRelation.java
new file mode 100644
index 00000000..9bab80c9
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslatedRelation.java
@@ -0,0 +1,22 @@
+package tools.refinery.store.reasoning.translator;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.literal.CallPolarity;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.reasoning.PartialInterpretation;
+import tools.refinery.store.reasoning.literal.Modality;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.TruthValue;
+
+import java.util.List;
+
+public interface TranslatedRelation {
+        PartialRelation getSource();
+
+        void configure(List<Advice> advices);
+
+        List<Literal> call(CallPolarity polarity, Modality modality, List<Variable> arguments);
+
+        PartialInterpretation<TruthValue, Boolean> createPartialInterpretation(Model model);
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationUnit.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationUnit.java
new file mode 100644
index 00000000..24b93911
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/TranslationUnit.java
@@ -0,0 +1,32 @@
+package tools.refinery.store.reasoning.translator;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelStoreBuilder;
+import tools.refinery.store.reasoning.ReasoningBuilder;
+
+import java.util.Collection;
+
+public abstract class TranslationUnit {
+        private ReasoningBuilder reasoningBuilder;
+
+        protected ReasoningBuilder getReasoningBuilder() {
+                return reasoningBuilder;
+        }
+
+        public void setPartialInterpretationBuilder(ReasoningBuilder reasoningBuilder) {
+                this.reasoningBuilder = reasoningBuilder;
+                configureReasoningBuilder();
+        }
+
+        protected ModelStoreBuilder getModelStoreBuilder() {
+                return reasoningBuilder.getStoreBuilder();
+        }
+
+        protected void configureReasoningBuilder() {
+                // Nothing to configure by default.
+        }
+
+        public abstract Collection<TranslatedRelation> getTranslatedRelations();
+
+        public abstract void initializeModel(Model model, int nodeCount);
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionInterpretation.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionInterpretation.java
new file mode 100644
index 00000000..b703f142
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionInterpretation.java
@@ -0,0 +1,88 @@
+package tools.refinery.store.reasoning.translator.base;
+
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.model.Interpretation;
+import tools.refinery.store.query.ResultSet;
+import tools.refinery.store.reasoning.MergeResult;
+import tools.refinery.store.reasoning.PartialInterpretation;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+public class BaseDecisionInterpretation implements PartialInterpretation<TruthValue, Boolean> {
+        private final ReasoningAdapter reasoningAdapter;
+        private PartialRelation partialRelation;
+        private final ResultSet<Boolean> mustResultSet;
+        private final ResultSet<Boolean> mayResultSet;
+        private final ResultSet<Boolean> errorResultSet;
+        private final ResultSet<Boolean> currentResultSet;
+        private final Interpretation<TruthValue> interpretation;
+
+        public BaseDecisionInterpretation(ReasoningAdapter reasoningAdapter, ResultSet<Boolean> mustResultSet,
+                                                                          ResultSet<Boolean> mayResultSet, ResultSet<Boolean> errorResultSet,
+                                                                          ResultSet<Boolean> currentResultSet, Interpretation<TruthValue> interpretation) {
+                this.reasoningAdapter = reasoningAdapter;
+                this.mustResultSet = mustResultSet;
+                this.mayResultSet = mayResultSet;
+                this.errorResultSet = errorResultSet;
+                this.currentResultSet = currentResultSet;
+                this.interpretation = interpretation;
+        }
+
+        @Override
+        public ReasoningAdapter getAdapter() {
+                return reasoningAdapter;
+        }
+
+        @Override
+        public int countUnfinished() {
+                return 0;
+        }
+
+        @Override
+        public int countErrors() {
+                return errorResultSet.size();
+        }
+
+        @Override
+        public PartialRelation getPartialSymbol() {
+                return partialRelation;
+        }
+
+        @Override
+        public TruthValue get(Tuple key) {
+                return null;
+        }
+
+        @Override
+        public Cursor<Tuple, TruthValue> getAll() {
+                return null;
+        }
+
+        @Override
+        public MergeResult merge(Tuple key, TruthValue value) {
+                TruthValue newValue;
+                switch (value) {
+                case UNKNOWN -> {
+                        return MergeResult.UNCHANGED;
+                }
+                case TRUE -> newValue = mayResultSet.get(key) ? TruthValue.TRUE : TruthValue.ERROR;
+                case FALSE -> newValue = mustResultSet.get(key) ? TruthValue.ERROR : TruthValue.FALSE;
+                case ERROR -> newValue = TruthValue.ERROR;
+                default -> throw new IllegalArgumentException("Unknown truth value: " + value);
+                }
+                var oldValue = interpretation.put(key, newValue);
+                return oldValue == TruthValue.ERROR ? MergeResult.UNCHANGED : MergeResult.REFINED;
+        }
+
+        @Override
+        public Boolean getConcrete(Tuple key) {
+                return currentResultSet.get(key);
+        }
+
+        @Override
+        public Cursor<Tuple, Boolean> getAllConcrete() {
+                return null;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionTranslationUnit.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionTranslationUnit.java
new file mode 100644
index 00000000..36e2782a
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/BaseDecisionTranslationUnit.java
@@ -0,0 +1,49 @@
+package tools.refinery.store.reasoning.translator.base;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.seed.Seed;
+import tools.refinery.store.reasoning.seed.UniformSeed;
+import tools.refinery.store.reasoning.translator.TranslatedRelation;
+import tools.refinery.store.reasoning.translator.TranslationUnit;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+
+import java.util.Collection;
+import java.util.List;
+
+public class BaseDecisionTranslationUnit extends TranslationUnit {
+        private final PartialRelation partialRelation;
+        private final Seed<TruthValue> seed;
+        private final Symbol<TruthValue> symbol;
+
+        public BaseDecisionTranslationUnit(PartialRelation partialRelation, Seed<TruthValue> seed) {
+                if (seed.arity() != partialRelation.arity()) {
+                        throw new IllegalArgumentException("Expected seed with arity %d for %s, got arity %s"
+                                        .formatted(partialRelation.arity(), partialRelation, seed.arity()));
+                }
+                this.partialRelation = partialRelation;
+                this.seed = seed;
+                symbol = new Symbol<>(partialRelation.name(), partialRelation.arity(), TruthValue.class, TruthValue.UNKNOWN);
+        }
+
+        public BaseDecisionTranslationUnit(PartialRelation partialRelation) {
+                this(partialRelation, new UniformSeed<>(partialRelation.arity(), TruthValue.UNKNOWN));
+        }
+
+        @Override
+        protected void configureReasoningBuilder() {
+                getModelStoreBuilder().symbol(symbol);
+        }
+
+        @Override
+        public Collection<TranslatedRelation> getTranslatedRelations() {
+                return List.of(new TranslatedBaseDecision(getReasoningBuilder(), partialRelation, symbol));
+        }
+
+        @Override
+        public void initializeModel(Model model, int nodeCount) {
+                var interpretation = model.getInterpretation(symbol);
+                interpretation.putAll(seed.getCursor(TruthValue.UNKNOWN, nodeCount));
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/TranslatedBaseDecision.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/TranslatedBaseDecision.java
new file mode 100644
index 00000000..2294b4fd
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/base/TranslatedBaseDecision.java
@@ -0,0 +1,49 @@
+package tools.refinery.store.reasoning.translator.base;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.term.Variable;
+import tools.refinery.store.query.literal.CallPolarity;
+import tools.refinery.store.query.literal.Literal;
+import tools.refinery.store.reasoning.PartialInterpretation;
+import tools.refinery.store.reasoning.ReasoningBuilder;
+import tools.refinery.store.reasoning.literal.Modality;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.Advice;
+import tools.refinery.store.reasoning.translator.TranslatedRelation;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.representation.TruthValue;
+
+import java.util.List;
+
+class TranslatedBaseDecision implements TranslatedRelation {
+        private final ReasoningBuilder reasoningBuilder;
+        private final PartialRelation partialRelation;
+        private final Symbol<TruthValue> symbol;
+
+        public TranslatedBaseDecision(ReasoningBuilder reasoningBuilder, PartialRelation partialRelation,
+                                                                  Symbol<TruthValue> symbol) {
+                this.reasoningBuilder = reasoningBuilder;
+                this.partialRelation = partialRelation;
+                this.symbol = symbol;
+        }
+
+        @Override
+        public PartialRelation getSource() {
+                return partialRelation;
+        }
+
+        @Override
+        public void configure(List<Advice> advices) {
+
+        }
+
+        @Override
+        public List<Literal> call(CallPolarity polarity, Modality modality, List<Variable> arguments) {
+                return null;
+        }
+
+        @Override
+        public PartialInterpretation<TruthValue, Boolean> createPartialInterpretation(Model model) {
+                return null;
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/EliminatedType.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/EliminatedType.java
new file mode 100644
index 00000000..1b8d7cc9
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/EliminatedType.java
@@ -0,0 +1,6 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+
+record EliminatedType(PartialRelation replacement) implements TypeAnalysisResult {
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/ExtendedTypeInfo.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/ExtendedTypeInfo.java
new file mode 100644
index 00000000..43b8e1dd
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/ExtendedTypeInfo.java
@@ -0,0 +1,101 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import org.jetbrains.annotations.NotNull;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Objects;
+import java.util.Set;
+
+final class ExtendedTypeInfo implements Comparable<ExtendedTypeInfo> {
+        private final int index;
+        private final PartialRelation type;
+        private final TypeInfo typeInfo;
+        private final Set<PartialRelation> allSubtypes = new LinkedHashSet<>();
+        private final Set<PartialRelation> allSupertypes;
+        private final Set<PartialRelation> concreteSubtypesAndSelf = new LinkedHashSet<>();
+        private Set<PartialRelation> directSubtypes;
+        private final Set<PartialRelation> unsortedDirectSupertypes = new HashSet<>();
+
+        public ExtendedTypeInfo(int index, PartialRelation type, TypeInfo typeInfo) {
+                this.index = index;
+                this.type = type;
+                this.typeInfo = typeInfo;
+                this.allSupertypes = new LinkedHashSet<>(typeInfo.supertypes());
+        }
+
+        public PartialRelation getType() {
+                return type;
+        }
+
+        public TypeInfo getTypeInfo() {
+                return typeInfo;
+        }
+
+        public boolean isAbstractType() {
+                return getTypeInfo().abstractType();
+        }
+
+        public Set<PartialRelation> getAllSubtypes() {
+                return allSubtypes;
+        }
+
+        public Set<PartialRelation> getAllSupertypes() {
+                return allSupertypes;
+        }
+
+        public Set<PartialRelation> getAllSupertypesAndSelf() {
+                var allSubtypesAndSelf = new HashSet<PartialRelation>(allSupertypes.size() + 1);
+                addMust(allSubtypesAndSelf);
+                return allSubtypesAndSelf;
+        }
+
+        public Set<PartialRelation> getConcreteSubtypesAndSelf() {
+                return concreteSubtypesAndSelf;
+        }
+
+        public Set<PartialRelation> getDirectSubtypes() {
+                return directSubtypes;
+        }
+
+        public Set<PartialRelation> getUnsortedDirectSupertypes() {
+                return unsortedDirectSupertypes;
+        }
+
+        public void setDirectSubtypes(Set<PartialRelation> directSubtypes) {
+                this.directSubtypes = directSubtypes;
+        }
+
+        public boolean allowsAllConcreteTypes(Set<PartialRelation> concreteTypes) {
+                for (var concreteType : concreteTypes) {
+                        if (!concreteSubtypesAndSelf.contains(concreteType)) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+
+        public void addMust(Set<PartialRelation> mustTypes) {
+                mustTypes.add(type);
+                mustTypes.addAll(allSupertypes);
+        }
+
+        @Override
+        public int compareTo(@NotNull ExtendedTypeInfo extendedTypeInfo) {
+                return Integer.compare(index, extendedTypeInfo.index);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                ExtendedTypeInfo that = (ExtendedTypeInfo) o;
+                return index == that.index;
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(index);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMayTypeRelationView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMayTypeRelationView.java
new file mode 100644
index 00000000..12c37c86
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMayTypeRelationView.java
@@ -0,0 +1,19 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.query.view.TuplePreservingRelationView;
+import tools.refinery.store.tuple.Tuple;
+
+class InferredMayTypeRelationView extends TuplePreservingRelationView<InferredType> {
+        private final PartialRelation type;
+
+        InferredMayTypeRelationView(PartialRelation type) {
+                super(TypeHierarchyTranslationUnit.INFERRED_TYPE_SYMBOL, "%s#may".formatted(type));
+                this.type = type;
+        }
+
+        @Override
+        public boolean filter(Tuple key, InferredType value) {
+                return value.mayConcreteTypes().contains(type);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMustTypeRelationView.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMustTypeRelationView.java
new file mode 100644
index 00000000..975f627e
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredMustTypeRelationView.java
@@ -0,0 +1,19 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.query.view.TuplePreservingRelationView;
+import tools.refinery.store.tuple.Tuple;
+
+class InferredMustTypeRelationView extends TuplePreservingRelationView<InferredType> {
+        private final PartialRelation type;
+
+        InferredMustTypeRelationView(PartialRelation type) {
+                super(TypeHierarchyTranslationUnit.INFERRED_TYPE_SYMBOL, "%s#must".formatted(type));
+                this.type = type;
+        }
+
+        @Override
+        public boolean filter(Tuple key, InferredType value) {
+                return value.mustTypes().contains(type);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredType.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredType.java
new file mode 100644
index 00000000..a366e262
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredType.java
@@ -0,0 +1,30 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+
+import java.util.Collections;
+import java.util.Set;
+
+record InferredType(Set<PartialRelation> mustTypes, Set<PartialRelation> mayConcreteTypes,
+                                        PartialRelation currentType) {
+        public static final InferredType UNTYPED = new InferredType(Set.of(), Set.of(), null);
+
+        public InferredType(Set<PartialRelation> mustTypes, Set<PartialRelation> mayConcreteTypes,
+                                                PartialRelation currentType) {
+                this.mustTypes = Collections.unmodifiableSet(mustTypes);
+                this.mayConcreteTypes = Collections.unmodifiableSet(mayConcreteTypes);
+                this.currentType = currentType;
+        }
+
+        public boolean isConsistent() {
+                return currentType != null || mustTypes.isEmpty();
+        }
+
+        public boolean isMust(PartialRelation partialRelation) {
+                return mustTypes.contains(partialRelation);
+        }
+
+        public boolean isMayConcrete(PartialRelation partialRelation) {
+                return mayConcreteTypes.contains(partialRelation);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/PreservedType.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/PreservedType.java
new file mode 100644
index 00000000..63dba964
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/PreservedType.java
@@ -0,0 +1,136 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.TruthValue;
+
+import java.util.*;
+
+final class PreservedType implements TypeAnalysisResult {
+        private final ExtendedTypeInfo extendedTypeInfo;
+        private final List<PartialRelation> directSubtypes;
+        private final List<ExtendedTypeInfo> allExternalTypeInfoList;
+        private final InferredType inferredType;
+
+        public PreservedType(ExtendedTypeInfo extendedTypeInfo, List<ExtendedTypeInfo> allExternalTypeInfoList) {
+                this.extendedTypeInfo = extendedTypeInfo;
+                directSubtypes = List.copyOf(extendedTypeInfo.getDirectSubtypes());
+                this.allExternalTypeInfoList = allExternalTypeInfoList;
+                inferredType = propagateMust(extendedTypeInfo.getAllSupertypesAndSelf(),
+                                extendedTypeInfo.getConcreteSubtypesAndSelf());
+        }
+
+        public PartialRelation type() {
+                return extendedTypeInfo.getType();
+        }
+
+        public List<PartialRelation> getDirectSubtypes() {
+                return directSubtypes;
+        }
+
+        public boolean isAbstractType() {
+                return extendedTypeInfo.isAbstractType();
+        }
+
+        public boolean isVacuous() {
+                return isAbstractType() && directSubtypes.isEmpty();
+        }
+
+        public InferredType asInferredType() {
+                return inferredType;
+        }
+
+        public InferredType merge(InferredType inferredType, TruthValue value) {
+                return switch (value) {
+                        case UNKNOWN -> inferredType;
+                        case TRUE -> addMust(inferredType);
+                        case FALSE -> removeMay(inferredType);
+                        case ERROR -> addError(inferredType);
+                };
+        }
+
+        private InferredType addMust(InferredType inferredType) {
+                var originalMustTypes = inferredType.mustTypes();
+                if (originalMustTypes.contains(type())) {
+                        return inferredType;
+                }
+                var mustTypes = new HashSet<>(originalMustTypes);
+                extendedTypeInfo.addMust(mustTypes);
+                var originalMayConcreteTypes = inferredType.mayConcreteTypes();
+                var mayConcreteTypes = new LinkedHashSet<>(originalMayConcreteTypes);
+                Set<PartialRelation> mayConcreteTypesResult;
+                if (mayConcreteTypes.retainAll(extendedTypeInfo.getConcreteSubtypesAndSelf())) {
+                        mayConcreteTypesResult = mayConcreteTypes;
+                } else {
+                        mayConcreteTypesResult = originalMayConcreteTypes;
+                }
+                return propagateMust(mustTypes, mayConcreteTypesResult);
+        }
+
+        private InferredType removeMay(InferredType inferredType) {
+                var originalMayConcreteTypes = inferredType.mayConcreteTypes();
+                var mayConcreteTypes = new LinkedHashSet<>(originalMayConcreteTypes);
+                if (!mayConcreteTypes.removeAll(extendedTypeInfo.getConcreteSubtypesAndSelf())) {
+                        return inferredType;
+                }
+                return propagateMust(inferredType.mustTypes(), mayConcreteTypes);
+        }
+
+        private InferredType addError(InferredType inferredType) {
+                var originalMustTypes = inferredType.mustTypes();
+                if (originalMustTypes.contains(type())) {
+                        if (inferredType.mayConcreteTypes().isEmpty()) {
+                                return inferredType;
+                        }
+                        return new InferredType(originalMustTypes, Set.of(), null);
+                }
+                var mustTypes = new HashSet<>(originalMustTypes);
+                extendedTypeInfo.addMust(mustTypes);
+                return new InferredType(mustTypes, Set.of(), null);
+        }
+
+        private InferredType propagateMust(Set<PartialRelation> originalMustTypes,
+                                                                           Set<PartialRelation> mayConcreteTypes) {
+                // It is possible that there is not type at all, do not force one by propagation.
+                var maybeUntyped = originalMustTypes.isEmpty();
+                // Para-consistent case, do not propagate must types to avoid logical explosion.
+                var paraConsistentOrSurelyUntyped = mayConcreteTypes.isEmpty();
+                if (maybeUntyped || paraConsistentOrSurelyUntyped) {
+                        return new InferredType(originalMustTypes, mayConcreteTypes, null);
+                }
+                var currentType = computeCurrentType(mayConcreteTypes);
+                var mustTypes = new HashSet<>(originalMustTypes);
+                boolean changed = false;
+                for (var newMustExtendedTypeInfo : allExternalTypeInfoList) {
+                        var newMustType = newMustExtendedTypeInfo.getType();
+                        if (mustTypes.contains(newMustType)) {
+                                continue;
+                        }
+                        if (newMustExtendedTypeInfo.allowsAllConcreteTypes(mayConcreteTypes)) {
+                                newMustExtendedTypeInfo.addMust(mustTypes);
+                                changed = true;
+                        }
+                }
+                if (!changed) {
+                        return new InferredType(originalMustTypes, mayConcreteTypes, currentType);
+                }
+                return new InferredType(mustTypes, mayConcreteTypes, currentType);
+        }
+
+        /**
+         * Returns a concrete type that is allowed by a (consistent, i.e., nonempty) set of <b>may</b> concrete types.
+         *
+         * @param mayConcreteTypes The set of allowed concrete types. Must not be empty.
+         * @return The first concrete type that is allowed by {@code matConcreteTypes}.
+         */
+        private PartialRelation computeCurrentType(Set<PartialRelation> mayConcreteTypes) {
+                for (var concreteExtendedTypeInfo : allExternalTypeInfoList) {
+                        var concreteType = concreteExtendedTypeInfo.getType();
+                        if (!concreteExtendedTypeInfo.isAbstractType() && mayConcreteTypes.contains(concreteType)) {
+                                return concreteType;
+                        }
+                }
+                // We have already filtered out the para-consistent case in {@link #propagateMust(Set<PartialRelation>,
+                // Set<PartialRelation>}.
+                throw new AssertionError("No concrete type in %s".formatted(mayConcreteTypes));
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalysisResult.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalysisResult.java
new file mode 100644
index 00000000..4f915108
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalysisResult.java
@@ -0,0 +1,4 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+sealed interface TypeAnalysisResult permits EliminatedType, PreservedType {
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzer.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzer.java
new file mode 100644
index 00000000..62f8e750
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzer.java
@@ -0,0 +1,202 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+
+import java.util.*;
+
+class TypeAnalyzer {
+        private final Map<PartialRelation, ExtendedTypeInfo> extendedTypeInfoMap;
+        private final Map<PartialRelation, PartialRelation> replacements = new LinkedHashMap<>();
+        private final InferredType unknownType;
+        private final Map<PartialRelation, TypeAnalysisResult> analysisResults;
+
+        public TypeAnalyzer(Map<PartialRelation, TypeInfo> typeInfoMap) {
+                int size = typeInfoMap.size();
+                extendedTypeInfoMap = new LinkedHashMap<>(size);
+                var concreteTypes = new LinkedHashSet<PartialRelation>();
+                int index = 0;
+                for (var entry : typeInfoMap.entrySet()) {
+                        var type = entry.getKey();
+                        var typeInfo = entry.getValue();
+                        extendedTypeInfoMap.put(type, new ExtendedTypeInfo(index, type, typeInfo));
+                        if (!typeInfo.abstractType()) {
+                                concreteTypes.add(type);
+                        }
+                        index++;
+                }
+                unknownType = new InferredType(Set.of(), concreteTypes, null);
+                computeAllSupertypes();
+                computeAllAndConcreteSubtypes();
+                computeDirectSubtypes();
+                eliminateTrivialSupertypes();
+                analysisResults = computeAnalysisResults();
+        }
+
+        public InferredType getUnknownType() {
+                return unknownType;
+        }
+
+        public Map<PartialRelation, TypeAnalysisResult> getAnalysisResults() {
+                return analysisResults;
+        }
+
+        private void computeAllSupertypes() {
+                boolean changed;
+                do {
+                        changed = false;
+                        for (var extendedTypeInfo : extendedTypeInfoMap.values()) {
+                                var found = new HashSet<PartialRelation>();
+                                var allSupertypes = extendedTypeInfo.getAllSupertypes();
+                                for (var supertype : allSupertypes) {
+                                        found.addAll(extendedTypeInfoMap.get(supertype).getAllSupertypes());
+                                }
+                                if (allSupertypes.addAll(found)) {
+                                        changed = true;
+                                }
+                        }
+                } while (changed);
+        }
+
+        private void computeAllAndConcreteSubtypes() {
+                for (var extendedTypeInfo : extendedTypeInfoMap.values()) {
+                        var type = extendedTypeInfo.getType();
+                        if (!extendedTypeInfo.isAbstractType()) {
+                                extendedTypeInfo.getConcreteSubtypesAndSelf().add(type);
+                        }
+                        for (var supertype : extendedTypeInfo.getAllSupertypes()) {
+                                if (type.equals(supertype)) {
+                                        throw new IllegalArgumentException("%s cannot be a supertype of itself".formatted(type));
+                                }
+                                var supertypeInfo = extendedTypeInfoMap.get(supertype);
+                                supertypeInfo.getAllSubtypes().add(type);
+                                if (!extendedTypeInfo.isAbstractType()) {
+                                        supertypeInfo.getConcreteSubtypesAndSelf().add(type);
+                                }
+                        }
+                }
+        }
+
+        private void computeDirectSubtypes() {
+                for (var extendedTypeInfo : extendedTypeInfoMap.values()) {
+                        var allSubtypes = extendedTypeInfo.getAllSubtypes();
+                        var directSubtypes = new LinkedHashSet<>(allSubtypes);
+                        var indirectSubtypes = new LinkedHashSet<PartialRelation>(allSubtypes.size());
+                        for (var subtype : allSubtypes) {
+                                indirectSubtypes.addAll(extendedTypeInfoMap.get(subtype).getAllSubtypes());
+                        }
+                        directSubtypes.removeAll(indirectSubtypes);
+                        extendedTypeInfo.setDirectSubtypes(directSubtypes);
+                }
+        }
+
+        private void eliminateTrivialSupertypes() {
+                boolean changed;
+                do {
+                        var toRemove = new ArrayList<PartialRelation>();
+                        for (var entry : extendedTypeInfoMap.entrySet()) {
+                                var extendedTypeInfo = entry.getValue();
+                                boolean isAbstract = extendedTypeInfo.isAbstractType();
+                                // Do not eliminate abstract types with 0 subtypes, because they can be used para-consistently, i.e.,
+                                // an object determined to <b>must</b> have an abstract type with 0 subtypes <b>may not</b> ever exist.
+                                boolean hasSingleDirectSubtype = extendedTypeInfo.getDirectSubtypes().size() == 1;
+                                if (isAbstract && hasSingleDirectSubtype) {
+                                        toRemove.add(entry.getKey());
+                                }
+                        }
+                        toRemove.forEach(this::removeTrivialType);
+                        changed = !toRemove.isEmpty();
+                } while (changed);
+        }
+
+        private void removeTrivialType(PartialRelation trivialType) {
+                var extendedTypeInfo = extendedTypeInfoMap.get(trivialType);
+                var iterator = extendedTypeInfo.getDirectSubtypes().iterator();
+                if (!iterator.hasNext()) {
+                        throw new AssertionError("Expected trivial supertype %s to have a direct subtype"
+                                        .formatted(trivialType));
+                }
+                PartialRelation replacement = setReplacement(trivialType, iterator.next());
+                if (iterator.hasNext()) {
+                        throw new AssertionError("Expected trivial supertype %s to have at most 1 direct subtype"
+                                        .formatted(trivialType));
+                }
+                replacements.put(trivialType, replacement);
+                for (var supertype : extendedTypeInfo.getAllSupertypes()) {
+                        var extendedSupertypeInfo = extendedTypeInfoMap.get(supertype);
+                        if (!extendedSupertypeInfo.getAllSubtypes().remove(trivialType)) {
+                                throw new AssertionError("Expected %s to be subtype of %s".formatted(trivialType, supertype));
+                        }
+                        var directSubtypes = extendedSupertypeInfo.getDirectSubtypes();
+                        if (directSubtypes.remove(trivialType)) {
+                                directSubtypes.add(replacement);
+                        }
+                }
+                for (var subtype : extendedTypeInfo.getAllSubtypes()) {
+                        var extendedSubtypeInfo = extendedTypeInfoMap.get(subtype);
+                        if (!extendedSubtypeInfo.getAllSupertypes().remove(trivialType)) {
+                                throw new AssertionError("Expected %s to be supertype of %s".formatted(trivialType, subtype));
+                        }
+                }
+                extendedTypeInfoMap.remove(trivialType);
+        }
+
+        private PartialRelation setReplacement(PartialRelation trivialRelation, PartialRelation replacement) {
+                if (replacement == null) {
+                        return trivialRelation;
+                }
+                var resolved = setReplacement(replacement, replacements.get(replacement));
+                replacements.put(trivialRelation, resolved);
+                return resolved;
+        }
+
+        private Map<PartialRelation, TypeAnalysisResult> computeAnalysisResults() {
+                var allExtendedTypeInfoList = sortTypes();
+                var results = new LinkedHashMap<PartialRelation, TypeAnalysisResult>(
+                                allExtendedTypeInfoList.size() + replacements.size());
+                for (var extendedTypeInfo : allExtendedTypeInfoList) {
+                        var type = extendedTypeInfo.getType();
+                        results.put(type, new PreservedType(extendedTypeInfo, allExtendedTypeInfoList));
+                }
+                for (var entry : replacements.entrySet()) {
+                        var type = entry.getKey();
+                        results.put(type, new EliminatedType(entry.getValue()));
+                }
+                return Collections.unmodifiableMap(results);
+        }
+
+        private List<ExtendedTypeInfo> sortTypes() {
+                // Invert {@code directSubtypes} to keep track of the out-degree of types.
+                for (var extendedTypeInfo : extendedTypeInfoMap.values()) {
+                        for (var directSubtype : extendedTypeInfo.getDirectSubtypes()) {
+                                var extendedDirectSubtypeInfo = extendedTypeInfoMap.get(directSubtype);
+                                extendedDirectSubtypeInfo.getUnsortedDirectSupertypes().add(extendedTypeInfo.getType());
+                        }
+                }
+                // Build a <i>inverse</i> topological order ({@code extends} edges always points to earlier nodes in the order,
+                // breaking ties according to the original order ({@link ExtendedTypeInfo#index}) to form a 'stable' sort.
+                // See, e.g., https://stackoverflow.com/a/11236027.
+                var priorityQueue = new PriorityQueue<ExtendedTypeInfo>();
+                for (var extendedTypeInfo : extendedTypeInfoMap.values()) {
+                        if (extendedTypeInfo.getUnsortedDirectSupertypes().isEmpty()) {
+                                priorityQueue.add(extendedTypeInfo);
+                        }
+                }
+                var sorted = new ArrayList<ExtendedTypeInfo>(extendedTypeInfoMap.size());
+                while (!priorityQueue.isEmpty()) {
+                        var extendedTypeInfo = priorityQueue.remove();
+                        sorted.add(extendedTypeInfo);
+                        for (var directSubtype : extendedTypeInfo.getDirectSubtypes()) {
+                                var extendedDirectSubtypeInfo = extendedTypeInfoMap.get(directSubtype);
+                                var unsortedDirectSupertypes = extendedDirectSubtypeInfo.getUnsortedDirectSupertypes();
+                                if (!unsortedDirectSupertypes.remove(extendedTypeInfo.getType())) {
+                                        throw new AssertionError("Expected %s to be a direct supertype of %s"
+                                                        .formatted(extendedTypeInfo.getType(), directSubtype));
+                                }
+                                if (unsortedDirectSupertypes.isEmpty()) {
+                                        priorityQueue.add(extendedDirectSubtypeInfo);
+                                }
+                        }
+                }
+                return Collections.unmodifiableList(sorted);
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslationUnit.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslationUnit.java
new file mode 100644
index 00000000..4b0761f2
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeHierarchyTranslationUnit.java
@@ -0,0 +1,32 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.reasoning.translator.TranslatedRelation;
+import tools.refinery.store.reasoning.translator.TranslationUnit;
+import tools.refinery.store.representation.Symbol;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+public class TypeHierarchyTranslationUnit extends TranslationUnit {
+        static final Symbol<InferredType> INFERRED_TYPE_SYMBOL = new Symbol<>("inferredType", 1,
+                        InferredType.class, InferredType.UNTYPED);
+
+        private final TypeAnalyzer typeAnalyzer;
+
+        public TypeHierarchyTranslationUnit(Map<PartialRelation, TypeInfo> typeInfoMap) {
+                typeAnalyzer = new TypeAnalyzer(typeInfoMap);
+        }
+
+        @Override
+        public Collection<TranslatedRelation> getTranslatedRelations() {
+                return List.of();
+        }
+
+        @Override
+        public void initializeModel(Model model, int nodeCount) {
+
+        }
+}
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeInfo.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeInfo.java
new file mode 100644
index 00000000..313df4df
--- /dev/null
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeInfo.java
@@ -0,0 +1,46 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+
+import java.util.*;
+
+public record TypeInfo(Collection<PartialRelation> supertypes, boolean abstractType) {
+        public static Builder builder() {
+                return new Builder();
+        }
+
+        public static class Builder {
+                private final Set<PartialRelation> supertypes = new LinkedHashSet<>();
+                private boolean abstractType;
+
+                private Builder() {
+                }
+
+                public Builder supertypes(Collection<PartialRelation> supertypes) {
+                        this.supertypes.addAll(supertypes);
+                        return this;
+                }
+
+                public Builder supertypes(PartialRelation... supertypes) {
+                        return supertypes(List.of(supertypes));
+                }
+
+                public Builder supertype(PartialRelation supertype) {
+                        supertypes.add(supertype);
+                        return this;
+                }
+
+                public Builder abstractType(boolean abstractType) {
+                        this.abstractType = abstractType;
+                        return this;
+                }
+
+                public Builder abstractType() {
+                        return abstractType(true);
+                }
+
+                public TypeInfo build() {
+                        return new TypeInfo(Collections.unmodifiableSet(supertypes), abstractType);
+                }
+        }
+}
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredTypeTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredTypeTest.java
new file mode 100644
index 00000000..a8df2312
--- /dev/null
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/InferredTypeTest.java
@@ -0,0 +1,32 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+
+import java.util.Set;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+class InferredTypeTest {
+        private final PartialRelation c1 = new PartialRelation("C1", 1);
+        private final PartialRelation c2 = new PartialRelation("C2", 1);
+
+        @Test
+        void untypedIsConsistentTest() {
+                var sut = new InferredType(Set.of(), Set.of(c1, c2), null);
+                assertThat(sut.isConsistent(), is(true));
+        }
+
+        @Test
+        void typedIsConsistentTest() {
+                var sut = new InferredType(Set.of(c1), Set.of(c1, c2), c1);
+                assertThat(sut.isConsistent(), is(true));
+        }
+
+        @Test
+        void typedIsInconsistentTest() {
+                var sut = new InferredType(Set.of(c1), Set.of(), null);
+                assertThat(sut.isConsistent(), is(false));
+        }
+}
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzerExampleHierarchyTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzerExampleHierarchyTest.java
new file mode 100644
index 00000000..b2c1ef1b
--- /dev/null
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzerExampleHierarchyTest.java
@@ -0,0 +1,203 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.TruthValue;
+
+import java.util.LinkedHashMap;
+import java.util.Set;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+class TypeAnalyzerExampleHierarchyTest {
+        private final PartialRelation a1 = new PartialRelation("A1", 1);
+        private final PartialRelation a2 = new PartialRelation("A2", 1);
+        private final PartialRelation a3 = new PartialRelation("A3", 1);
+        private final PartialRelation a4 = new PartialRelation("A4", 1);
+        private final PartialRelation a5 = new PartialRelation("A5", 1);
+        private final PartialRelation c1 = new PartialRelation("C1", 1);
+        private final PartialRelation c2 = new PartialRelation("C2", 1);
+        private final PartialRelation c3 = new PartialRelation("C3", 1);
+        private final PartialRelation c4 = new PartialRelation("C4", 1);
+
+        private TypeAnalyzer sut;
+        private TypeAnalyzerTester tester;
+
+        @BeforeEach
+        void beforeEach() {
+                var typeInfoMap = new LinkedHashMap<PartialRelation, TypeInfo>();
+                typeInfoMap.put(a1, TypeInfo.builder().abstractType().build());
+                typeInfoMap.put(a2, TypeInfo.builder().abstractType().build());
+                typeInfoMap.put(a3, TypeInfo.builder().abstractType().build());
+                typeInfoMap.put(a4, TypeInfo.builder().abstractType().build());
+                typeInfoMap.put(a5, TypeInfo.builder().abstractType().build());
+                typeInfoMap.put(c1, TypeInfo.builder().supertypes(a1, a4).build());
+                typeInfoMap.put(c2, TypeInfo.builder().supertypes(a1, a2, a3, a4).build());
+                typeInfoMap.put(c3, TypeInfo.builder().supertype(a3).build());
+                typeInfoMap.put(c4, TypeInfo.builder().supertype(a4).build());
+                sut = new TypeAnalyzer(typeInfoMap);
+                tester = new TypeAnalyzerTester(sut);
+        }
+
+        @Test
+        void analysisResultsTest() {
+                assertAll(
+                                () -> tester.assertAbstractType(a1, c1, c2),
+                                () -> tester.assertEliminatedType(a2, c2),
+                                () -> tester.assertAbstractType(a3, c2, c3),
+                                () -> tester.assertAbstractType(a4, c1, c2, c4),
+                                () -> tester.assertVacuousType(a5),
+                                () -> tester.assertConcreteType(c1),
+                                () -> tester.assertConcreteType(c2),
+                                () -> tester.assertConcreteType(c3),
+                                () -> tester.assertConcreteType(c4)
+                );
+        }
+
+        @Test
+        void inferredTypesTest() {
+                assertAll(
+                                () -> assertThat(sut.getUnknownType(), is(new InferredType(Set.of(), Set.of(c1, c2, c3, c4), null))),
+                                () -> assertThat(tester.getInferredType(a1), is(new InferredType(Set.of(a1, a4), Set.of(c1, c2), c1))),
+                                () -> assertThat(tester.getInferredType(a3), is(new InferredType(Set.of(a3), Set.of(c2, c3), c2))),
+                                () -> assertThat(tester.getInferredType(a4), is(new InferredType(Set.of(a4), Set.of(c1, c2, c4), c1))),
+                                () -> assertThat(tester.getInferredType(a5), is(new InferredType(Set.of(a5), Set.of(), null))),
+                                () -> assertThat(tester.getInferredType(c1), is(new InferredType(Set.of(a1, a4, c1), Set.of(c1), c1))),
+                                () -> assertThat(tester.getInferredType(c2),
+                                                is(new InferredType(Set.of(a1, a3, a4, c2), Set.of(c2), c2))),
+                                () -> assertThat(tester.getInferredType(c3), is(new InferredType(Set.of(a3, c3), Set.of(c3), c3))),
+                                () -> assertThat(tester.getInferredType(c4), is(new InferredType(Set.of(a4, c4), Set.of(c4), c4)))
+                );
+        }
+
+        @Test
+        void consistentMustTest() {
+                var a1Result = tester.getPreservedType(a1);
+                var a3Result = tester.getPreservedType(a3);
+                var expected = new InferredType(Set.of(a1, a3, a4, c2), Set.of(c2), c2);
+                assertAll(
+                                () -> assertThat(a1Result.merge(a3Result.asInferredType(), TruthValue.TRUE), is(expected)),
+                                () -> assertThat(a3Result.merge(a1Result.asInferredType(), TruthValue.TRUE), is(expected)),
+                                () -> assertThat(a1Result.merge(sut.getUnknownType(), TruthValue.TRUE), is(a1Result.asInferredType())),
+                                () -> assertThat(a3Result.merge(sut.getUnknownType(), TruthValue.TRUE), is(a3Result.asInferredType())),
+                                () -> assertThat(a1Result.merge(a1Result.asInferredType(), TruthValue.TRUE),
+                                                is(a1Result.asInferredType()))
+                );
+        }
+
+        @Test
+        void consistentMayNotTest() {
+                var a1Result = tester.getPreservedType(a1);
+                var a3Result = tester.getPreservedType(a3);
+                var a4Result = tester.getPreservedType(a4);
+                assertAll(
+                                () -> assertThat(a1Result.merge(a3Result.asInferredType(), TruthValue.FALSE),
+                                                is(new InferredType(Set.of(a3, c3), Set.of(c3), c3))),
+                                () -> assertThat(a3Result.merge(a1Result.asInferredType(), TruthValue.FALSE),
+                                                is(new InferredType(Set.of(a1, a4, c1), Set.of(c1), c1))),
+                                () -> assertThat(a4Result.merge(a3Result.asInferredType(), TruthValue.FALSE),
+                                                is(new InferredType(Set.of(a3, c3), Set.of(c3), c3))),
+                                () -> assertThat(a3Result.merge(a4Result.asInferredType(), TruthValue.FALSE),
+                                                is(new InferredType(Set.of(a4), Set.of(c1, c4), c1))),
+                                () -> assertThat(a1Result.merge(sut.getUnknownType(), TruthValue.FALSE),
+                                                is(new InferredType(Set.of(), Set.of(c3, c4), null))),
+                                () -> assertThat(a3Result.merge(sut.getUnknownType(), TruthValue.FALSE),
+                                                is(new InferredType(Set.of(), Set.of(c1, c4), null))),
+                                () -> assertThat(a4Result.merge(sut.getUnknownType(), TruthValue.FALSE),
+                                                is(new InferredType(Set.of(), Set.of(c3), null)))
+                );
+        }
+
+        @Test
+        void consistentErrorTest() {
+                var c1Result = tester.getPreservedType(c1);
+                var a4Result = tester.getPreservedType(a4);
+                var expected = new InferredType(Set.of(c1, a1, a4), Set.of(), null);
+                assertAll(
+                                () -> assertThat(c1Result.merge(a4Result.asInferredType(), TruthValue.ERROR), is(expected)),
+                                () -> assertThat(a4Result.merge(c1Result.asInferredType(), TruthValue.ERROR), is(expected))
+                );
+        }
+
+        @Test
+        void consistentUnknownTest() {
+                var c1Result = tester.getPreservedType(c1);
+                var a4Result = tester.getPreservedType(a4);
+                assertAll(
+                                () -> assertThat(c1Result.merge(a4Result.asInferredType(), TruthValue.UNKNOWN),
+                                                is(a4Result.asInferredType())),
+                                () -> assertThat(a4Result.merge(c1Result.asInferredType(), TruthValue.UNKNOWN),
+                                                is(c1Result.asInferredType()))
+                );
+        }
+
+        @Test
+        void inconsistentMustTest() {
+                var a1Result = tester.getPreservedType(a1);
+                var c3Result = tester.getPreservedType(c3);
+                assertAll(
+                                () -> assertThat(a1Result.merge(c3Result.asInferredType(), TruthValue.TRUE),
+                                                is(new InferredType(Set.of(a1, a3, c3), Set.of(), null))),
+                                () -> assertThat(c3Result.merge(a1Result.asInferredType(), TruthValue.TRUE),
+                                                is(new InferredType(Set.of(a1, a3, a4, c3), Set.of(), null)))
+                );
+        }
+
+        @Test
+        void inconsistentMayNotTest() {
+                var a1Result = tester.getPreservedType(a1);
+                var a4Result = tester.getPreservedType(a4);
+                var c1Result = tester.getPreservedType(c1);
+                assertAll(
+                                () -> assertThat(a4Result.merge(a1Result.asInferredType(), TruthValue.FALSE),
+                                                is(new InferredType(Set.of(a1, a4), Set.of(), null))),
+                                () -> assertThat(a1Result.merge(c1Result.asInferredType(), TruthValue.FALSE),
+                                                is(new InferredType(Set.of(a1, a4, c1), Set.of(), null))),
+                                () -> assertThat(a4Result.merge(c1Result.asInferredType(), TruthValue.FALSE),
+                                                is(new InferredType(Set.of(a1, a4, c1), Set.of(), null))),
+                                () -> assertThat(a1Result.merge(a1Result.asInferredType(), TruthValue.FALSE),
+                                                is(new InferredType(Set.of(a1, a4), Set.of(), null)))
+                );
+        }
+
+        @Test
+        void vacuousMustTest() {
+                var c1Result = tester.getPreservedType(c1);
+                var a5Result = tester.getPreservedType(a5);
+                assertAll(
+                                () -> assertThat(c1Result.merge(a5Result.asInferredType(), TruthValue.TRUE),
+                                                is(new InferredType(Set.of(a1, a4, a5, c1), Set.of(), null))),
+                                () -> assertThat(a5Result.merge(c1Result.asInferredType(), TruthValue.TRUE),
+                                                is(new InferredType(Set.of(a1, a4, a5, c1), Set.of(), null)))
+                );
+        }
+
+        @Test
+        void vacuousMayNotTest() {
+                var c1Result = tester.getPreservedType(c1);
+                var a5Result = tester.getPreservedType(a5);
+                assertAll(
+                                () -> assertThat(c1Result.merge(a5Result.asInferredType(), TruthValue.FALSE),
+                                                is(a5Result.asInferredType())),
+                                () -> assertThat(a5Result.merge(c1Result.asInferredType(), TruthValue.FALSE),
+                                                is(c1Result.asInferredType()))
+                );
+        }
+
+        @Test
+        void vacuousErrorTest() {
+                var c1Result = tester.getPreservedType(c1);
+                var a5Result = tester.getPreservedType(a5);
+                assertAll(
+                                () -> assertThat(c1Result.merge(a5Result.asInferredType(), TruthValue.ERROR),
+                                                is(new InferredType(Set.of(a1, a4, a5, c1), Set.of(), null))),
+                                () -> assertThat(a5Result.merge(c1Result.asInferredType(), TruthValue.ERROR),
+                                                is(new InferredType(Set.of(a1, a4, a5, c1), Set.of(), null))),
+                                () -> assertThat(a5Result.merge(a5Result.asInferredType(), TruthValue.ERROR),
+                                                is(a5Result.asInferredType()))
+                );
+        }
+}
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzerTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzerTest.java
new file mode 100644
index 00000000..b7b69ed8
--- /dev/null
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzerTest.java
@@ -0,0 +1,200 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.reasoning.representation.PartialRelation;
+import tools.refinery.store.representation.TruthValue;
+
+import java.util.LinkedHashMap;
+import java.util.Set;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class TypeAnalyzerTest {
+        @Test
+        void directSupertypesTest() {
+                var c1 = new PartialRelation("C1", 1);
+                var c2 = new PartialRelation("C2", 1);
+                var c3 = new PartialRelation("C3", 1);
+                var typeInfoMap = new LinkedHashMap<PartialRelation, TypeInfo>();
+                typeInfoMap.put(c1, TypeInfo.builder().supertypes(c2, c3).build());
+                typeInfoMap.put(c2, TypeInfo.builder().supertype(c3).build());
+                typeInfoMap.put(c3, TypeInfo.builder().build());
+
+                var sut = new TypeAnalyzer(typeInfoMap);
+                var tester = new TypeAnalyzerTester(sut);
+
+                assertAll(
+                                () -> tester.assertConcreteType(c1),
+                                () -> tester.assertConcreteType(c2, c1),
+                                () -> tester.assertConcreteType(c3, c2)
+                );
+        }
+
+        @Test
+        void typeEliminationAbstractToConcreteTest() {
+                var c1 = new PartialRelation("C1", 1);
+                var c2 = new PartialRelation("C2", 1);
+                var a11 = new PartialRelation("A11", 1);
+                var a12 = new PartialRelation("A12", 1);
+                var a21 = new PartialRelation("A21", 1);
+                var a22 = new PartialRelation("A22", 1);
+                var a3 = new PartialRelation("A3", 1);
+                var typeInfoMap = new LinkedHashMap<PartialRelation, TypeInfo>();
+                typeInfoMap.put(a3, TypeInfo.builder().abstractType().build());
+                typeInfoMap.put(a21, TypeInfo.builder().abstractType().supertype(a3).build());
+                typeInfoMap.put(a22, TypeInfo.builder().abstractType().supertype(a3).build());
+                typeInfoMap.put(a11, TypeInfo.builder().abstractType().supertypes(a21, a22).build());
+                typeInfoMap.put(a12, TypeInfo.builder().abstractType().supertypes(a21, a22).build());
+                typeInfoMap.put(c1, TypeInfo.builder().supertypes(a11, a12).build());
+                typeInfoMap.put(c2, TypeInfo.builder().supertype(a3).build());
+
+                var sut = new TypeAnalyzer(typeInfoMap);
+                var tester = new TypeAnalyzerTester(sut);
+
+                assertAll(
+                                () -> tester.assertConcreteType(c1),
+                                () -> tester.assertConcreteType(c2),
+                                () -> tester.assertEliminatedType(a11, c1),
+                                () -> tester.assertEliminatedType(a12, c1),
+                                () -> tester.assertEliminatedType(a21, c1),
+                                () -> tester.assertEliminatedType(a22, c1),
+                                () -> tester.assertAbstractType(a3, c1, c2)
+                );
+        }
+
+        @Test
+        void typeEliminationConcreteToAbstractTest() {
+                var c1 = new PartialRelation("C1", 1);
+                var c2 = new PartialRelation("C2", 1);
+                var a11 = new PartialRelation("A11", 1);
+                var a12 = new PartialRelation("A12", 1);
+                var a21 = new PartialRelation("A21", 1);
+                var a22 = new PartialRelation("A22", 1);
+                var a3 = new PartialRelation("A3", 1);
+                var typeInfoMap = new LinkedHashMap<PartialRelation, TypeInfo>();
+                typeInfoMap.put(c1, TypeInfo.builder().supertypes(a11, a12).build());
+                typeInfoMap.put(c2, TypeInfo.builder().supertype(a3).build());
+                typeInfoMap.put(a11, TypeInfo.builder().abstractType().supertypes(a21, a22).build());
+                typeInfoMap.put(a12, TypeInfo.builder().abstractType().supertypes(a21, a22).build());
+                typeInfoMap.put(a21, TypeInfo.builder().abstractType().supertype(a3).build());
+                typeInfoMap.put(a22, TypeInfo.builder().abstractType().supertype(a3).build());
+                typeInfoMap.put(a3, TypeInfo.builder().abstractType().build());
+
+                var sut = new TypeAnalyzer(typeInfoMap);
+                var tester = new TypeAnalyzerTester(sut);
+
+                assertAll(
+                                () -> tester.assertConcreteType(c1),
+                                () -> tester.assertConcreteType(c2),
+                                () -> tester.assertEliminatedType(a11, c1),
+                                () -> tester.assertEliminatedType(a12, c1),
+                                () -> tester.assertEliminatedType(a21, c1),
+                                () -> tester.assertEliminatedType(a22, c1),
+                                () -> tester.assertAbstractType(a3, c1, c2)
+                );
+        }
+
+        @Test
+        void preserveConcreteTypeTest() {
+                var c1 = new PartialRelation("C1", 1);
+                var a1 = new PartialRelation("A1", 1);
+                var c2 = new PartialRelation("C2", 1);
+                var a2 = new PartialRelation("A2", 1);
+                var typeInfoMap = new LinkedHashMap<PartialRelation, TypeInfo>();
+                typeInfoMap.put(c1, TypeInfo.builder().supertype(a1).build());
+                typeInfoMap.put(a1, TypeInfo.builder().abstractType().supertype(c2).build());
+                typeInfoMap.put(c2, TypeInfo.builder().supertype(a2).build());
+                typeInfoMap.put(a2, TypeInfo.builder().abstractType().build());
+
+                var sut = new TypeAnalyzer(typeInfoMap);
+                var tester = new TypeAnalyzerTester(sut);
+
+                assertAll(
+                                () -> tester.assertConcreteType(c1),
+                                () -> tester.assertEliminatedType(a1, c1),
+                                () -> tester.assertConcreteType(c2, c1),
+                                () -> tester.assertEliminatedType(a2, c2)
+                );
+        }
+
+        @Test
+        void mostGeneralCurrentTypeTest() {
+                var c1 = new PartialRelation("C1", 1);
+                var c2 = new PartialRelation("C2", 1);
+                var c3 = new PartialRelation("C3", 1);
+                var typeInfoMap = new LinkedHashMap<PartialRelation, TypeInfo>();
+                typeInfoMap.put(c1, TypeInfo.builder().supertype(c3).build());
+                typeInfoMap.put(c2, TypeInfo.builder().supertype(c3).build());
+                typeInfoMap.put(c3, TypeInfo.builder().build());
+
+                var sut = new TypeAnalyzer(typeInfoMap);
+                var tester = new TypeAnalyzerTester(sut);
+                var c3Result = tester.getPreservedType(c3);
+
+                var expected = new InferredType(Set.of(c3), Set.of(c1, c2, c3), c3);
+                assertAll(
+                                () -> assertThat(tester.getInferredType(c3), is(expected)),
+                                () -> assertThat(c3Result.merge(sut.getUnknownType(), TruthValue.TRUE), is(expected))
+                );
+        }
+
+        @Test
+        void preferFirstConcreteTypeTest() {
+                var a1 = new PartialRelation("A1", 1);
+                var c1 = new PartialRelation("C1", 1);
+                var c2 = new PartialRelation("C2", 1);
+                var c3 = new PartialRelation("C3", 1);
+                var c4 = new PartialRelation("C4", 1);
+                var typeInfoMap = new LinkedHashMap<PartialRelation, TypeInfo>();
+                typeInfoMap.put(c1, TypeInfo.builder().supertype(a1).build());
+                typeInfoMap.put(c2, TypeInfo.builder().supertype(a1).build());
+                typeInfoMap.put(c3, TypeInfo.builder().supertype(a1).build());
+                typeInfoMap.put(c4, TypeInfo.builder().supertype(c3).build());
+                typeInfoMap.put(a1, TypeInfo.builder().abstractType().build());
+
+                var sut = new TypeAnalyzer(typeInfoMap);
+                var tester = new TypeAnalyzerTester(sut);
+                var c1Result = tester.getPreservedType(c1);
+                var a1Result = tester.getPreservedType(a1);
+
+                assertThat(c1Result.merge(a1Result.asInferredType(), TruthValue.FALSE),
+                                is(new InferredType(Set.of(a1), Set.of(c2, c3, c4), c2)));
+        }
+
+        @Test
+        void preferFirstMostGeneralConcreteTypeTest() {
+                var a1 = new PartialRelation("A1", 1);
+                var c1 = new PartialRelation("C1", 1);
+                var c2 = new PartialRelation("C2", 1);
+                var c3 = new PartialRelation("C3", 1);
+                var c4 = new PartialRelation("C4", 1);
+                var typeInfoMap = new LinkedHashMap<PartialRelation, TypeInfo>();
+                typeInfoMap.put(c4, TypeInfo.builder().supertype(c3).build());
+                typeInfoMap.put(c3, TypeInfo.builder().supertype(a1).build());
+                typeInfoMap.put(c2, TypeInfo.builder().supertype(a1).build());
+                typeInfoMap.put(c1, TypeInfo.builder().supertype(a1).build());
+                typeInfoMap.put(a1, TypeInfo.builder().abstractType().build());
+
+                var sut = new TypeAnalyzer(typeInfoMap);
+                var tester = new TypeAnalyzerTester(sut);
+                var c1Result = tester.getPreservedType(c1);
+                var a1Result = tester.getPreservedType(a1);
+
+                assertThat(c1Result.merge(a1Result.asInferredType(), TruthValue.FALSE),
+                                is(new InferredType(Set.of(a1), Set.of(c2, c3, c4), c3)));
+        }
+
+        @Test
+        void circularTypeHierarchyTest() {
+                var c1 = new PartialRelation("C1", 1);
+                var c2 = new PartialRelation("C2", 1);
+                var typeInfoMap = new LinkedHashMap<PartialRelation, TypeInfo>();
+                typeInfoMap.put(c1, TypeInfo.builder().supertype(c2).build());
+                typeInfoMap.put(c2, TypeInfo.builder().supertype(c1).build());
+
+                assertThrows(IllegalArgumentException.class, () -> new TypeAnalyzer(typeInfoMap));
+        }
+}
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzerTester.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzerTester.java
new file mode 100644
index 00000000..56407730
--- /dev/null
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/typehierarchy/TypeAnalyzerTester.java
@@ -0,0 +1,51 @@
+package tools.refinery.store.reasoning.translator.typehierarchy;
+
+import tools.refinery.store.reasoning.representation.PartialRelation;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+import static org.hamcrest.Matchers.is;
+
+class TypeAnalyzerTester {
+        private final TypeAnalyzer sut;
+
+        public TypeAnalyzerTester(TypeAnalyzer sut) {
+                this.sut = sut;
+        }
+
+        public void assertAbstractType(PartialRelation partialRelation, PartialRelation... directSubtypes) {
+                assertPreservedType(partialRelation, true, false, directSubtypes);
+        }
+
+        public void assertVacuousType(PartialRelation partialRelation) {
+                assertPreservedType(partialRelation, true, true);
+        }
+
+        public void assertConcreteType(PartialRelation partialRelation, PartialRelation... directSubtypes) {
+                assertPreservedType(partialRelation, false, false, directSubtypes);
+        }
+
+        private void assertPreservedType(PartialRelation partialRelation, boolean isAbstract, boolean isVacuous,
+                                                                         PartialRelation... directSubtypes) {
+                var result = sut.getAnalysisResults().get(partialRelation);
+                assertThat(result, is(instanceOf(PreservedType.class)));
+                var preservedResult = (PreservedType) result;
+                assertThat(preservedResult.isAbstractType(), is(isAbstract));
+                assertThat(preservedResult.isVacuous(), is(isVacuous));
+                assertThat(preservedResult.getDirectSubtypes(), hasItems(directSubtypes));
+        }
+
+        public void assertEliminatedType(PartialRelation partialRelation, PartialRelation replacement) {
+                var result = sut.getAnalysisResults().get(partialRelation);
+                assertThat(result, is(instanceOf(EliminatedType.class)));
+                assertThat(((EliminatedType) result).replacement(), is(replacement));
+        }
+
+        public PreservedType getPreservedType(PartialRelation partialRelation) {
+                return (PreservedType) sut.getAnalysisResults().get(partialRelation);
+        }
+
+        public InferredType getInferredType(PartialRelation partialRelation) {
+                return getPreservedType(partialRelation).asInferredType();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/Cursors.java b/subprojects/store/src/main/java/tools/refinery/store/map/Cursors.java
new file mode 100644
index 00000000..fc8e628b
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/Cursors.java
@@ -0,0 +1,36 @@
+package tools.refinery.store.map;
+
+public final class Cursors {
+    private Cursors() {
+        throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+    }
+
+    public static <K, V> Cursor<K, V> empty() {
+        return new Empty<>();
+    }
+
+    private static class Empty<K, V> implements Cursor<K, V> {
+        private boolean terminated = false;
+
+        @Override
+        public K getKey() {
+            return null;
+        }
+
+        @Override
+        public V getValue() {
+            return null;
+        }
+
+        @Override
+        public boolean isTerminated() {
+            return terminated;
+        }
+
+        @Override
+        public boolean move() {
+            terminated = true;
+            return false;
+        }
+    }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/partial/PartialInterpretation.java b/subprojects/store/src/main/java/tools/refinery/store/partial/PartialInterpretation.java
deleted file mode 100644
index 331fa294..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/partial/PartialInterpretation.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package tools.refinery.store.partial;
-
-import tools.refinery.store.adapter.ModelAdapterBuilderFactory;
-import tools.refinery.store.model.ModelStoreBuilder;
-import tools.refinery.store.partial.internal.PartialInterpretationBuilderImpl;
-
-public final class PartialInterpretation extends ModelAdapterBuilderFactory<PartialInterpretationAdapter,
-                PartialInterpretationStoreAdapter, PartialInterpretationBuilder> {
-        public static final PartialInterpretation ADAPTER = new PartialInterpretation();
-
-        private PartialInterpretation() {
-                super(PartialInterpretationAdapter.class, PartialInterpretationStoreAdapter.class, PartialInterpretationBuilder.class);
-        }
-
-        @Override
-        public PartialInterpretationBuilder createBuilder(ModelStoreBuilder storeBuilder) {
-                return new PartialInterpretationBuilderImpl(storeBuilder);
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/partial/PartialInterpretationAdapter.java b/subprojects/store/src/main/java/tools/refinery/store/partial/PartialInterpretationAdapter.java
deleted file mode 100644
index 2c83a200..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/partial/PartialInterpretationAdapter.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package tools.refinery.store.partial;
-
-import tools.refinery.store.adapter.ModelAdapter;
-
-public interface PartialInterpretationAdapter extends ModelAdapter {
-        @Override
-        PartialInterpretationStoreAdapter getStoreAdapter();
-}
-
diff --git a/subprojects/store/src/main/java/tools/refinery/store/partial/PartialInterpretationBuilder.java b/subprojects/store/src/main/java/tools/refinery/store/partial/PartialInterpretationBuilder.java
deleted file mode 100644
index 0ec13836..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/partial/PartialInterpretationBuilder.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package tools.refinery.store.partial;
-
-import tools.refinery.store.adapter.ModelAdapterBuilder;
-import tools.refinery.store.model.ModelStore;
-
-public interface PartialInterpretationBuilder extends ModelAdapterBuilder {
-        @Override
-        PartialInterpretationStoreAdapter createStoreAdapter(ModelStore store);
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/partial/PartialInterpretationStoreAdapter.java b/subprojects/store/src/main/java/tools/refinery/store/partial/PartialInterpretationStoreAdapter.java
deleted file mode 100644
index d4eb770d..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/partial/PartialInterpretationStoreAdapter.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package tools.refinery.store.partial;
-
-import tools.refinery.store.adapter.ModelStoreAdapter;
-import tools.refinery.store.model.Model;
-
-public interface PartialInterpretationStoreAdapter extends ModelStoreAdapter {
-        @Override
-        PartialInterpretationAdapter createModelAdapter(Model model);
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/partial/internal/PartialInterpretationAdapterImpl.java b/subprojects/store/src/main/java/tools/refinery/store/partial/internal/PartialInterpretationAdapterImpl.java
deleted file mode 100644
index 4b3977c0..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/partial/internal/PartialInterpretationAdapterImpl.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package tools.refinery.store.partial.internal;
-
-import tools.refinery.store.model.Model;
-import tools.refinery.store.partial.PartialInterpretationAdapter;
-
-public class PartialInterpretationAdapterImpl implements PartialInterpretationAdapter {
-        private final Model model;
-        private final PartialInterpretationStoreAdapterImpl storeAdapter;
-
-        PartialInterpretationAdapterImpl(Model model, PartialInterpretationStoreAdapterImpl storeAdapter) {
-                this.model = model;
-                this.storeAdapter = storeAdapter;
-        }
-
-        @Override
-        public Model getModel() {
-                return model;
-        }
-
-        @Override
-        public PartialInterpretationStoreAdapterImpl getStoreAdapter() {
-                return storeAdapter;
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/partial/internal/PartialInterpretationBuilderImpl.java b/subprojects/store/src/main/java/tools/refinery/store/partial/internal/PartialInterpretationBuilderImpl.java
deleted file mode 100644
index 4609dc32..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/partial/internal/PartialInterpretationBuilderImpl.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package tools.refinery.store.partial.internal;
-
-import tools.refinery.store.adapter.AbstractModelAdapterBuilder;
-import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.model.ModelStoreBuilder;
-import tools.refinery.store.partial.PartialInterpretationBuilder;
-
-public class PartialInterpretationBuilderImpl extends AbstractModelAdapterBuilder implements PartialInterpretationBuilder {
-        public PartialInterpretationBuilderImpl(ModelStoreBuilder storeBuilder) {
-                super(storeBuilder);
-        }
-
-        @Override
-        public PartialInterpretationStoreAdapterImpl createStoreAdapter(ModelStore store) {
-                return null;
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/partial/internal/PartialInterpretationStoreAdapterImpl.java b/subprojects/store/src/main/java/tools/refinery/store/partial/internal/PartialInterpretationStoreAdapterImpl.java
deleted file mode 100644
index 970b802b..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/partial/internal/PartialInterpretationStoreAdapterImpl.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package tools.refinery.store.partial.internal;
-
-import tools.refinery.store.model.Model;
-import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.partial.PartialInterpretationStoreAdapter;
-
-public class PartialInterpretationStoreAdapterImpl implements PartialInterpretationStoreAdapter {
-        private final ModelStore store;
-
-        PartialInterpretationStoreAdapterImpl(ModelStore store) {
-                this.store = store;
-        }
-
-        @Override
-        public ModelStore getStore() {
-                return store;
-        }
-
-        @Override
-        public PartialInterpretationAdapterImpl createModelAdapter(Model model) {
-                return new PartialInterpretationAdapterImpl(model, this);
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/DNF.java b/subprojects/store/src/main/java/tools/refinery/store/query/DNF.java
deleted file mode 100644
index 95c5d787..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/DNF.java
+++ /dev/null
@@ -1,169 +0,0 @@
-package tools.refinery.store.query;
-
-import tools.refinery.store.query.atom.DNFAtom;
-
-import java.util.*;
-
-public final class DNF implements RelationLike {
-        private final String name;
-
-        private final String uniqueName;
-
-        private final List<Variable> parameters;
-
-        private final List<FunctionalDependency<Variable>> functionalDependencies;
-
-        private final List<DNFAnd> clauses;
-
-        private DNF(String name, List<Variable> parameters, List<FunctionalDependency<Variable>> functionalDependencies,
-                                List<DNFAnd> clauses) {
-                validateFunctionalDependencies(parameters, functionalDependencies);
-                this.name = name;
-                this.uniqueName = DNFUtils.generateUniqueName(name);
-                this.parameters = parameters;
-                this.functionalDependencies = functionalDependencies;
-                this.clauses = clauses;
-        }
-
-        private static void validateFunctionalDependencies(
-                        Collection<Variable> parameters, Collection<FunctionalDependency<Variable>> functionalDependencies) {
-                var parameterSet = new HashSet<>(parameters);
-                for (var functionalDependency : functionalDependencies) {
-                        validateParameters(parameters, parameterSet, functionalDependency.forEach(), functionalDependency);
-                        validateParameters(parameters, parameterSet, functionalDependency.unique(), functionalDependency);
-                }
-        }
-
-        private static void validateParameters(Collection<Variable> parameters, 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, parameters));
-                        }
-                }
-        }
-
-        @Override
-        public String name() {
-                return name;
-        }
-
-        public String getUniqueName() {
-                return uniqueName;
-        }
-
-        public List<Variable> getParameters() {
-                return parameters;
-        }
-
-        public List<FunctionalDependency<Variable>> getFunctionalDependencies() {
-                return functionalDependencies;
-        }
-
-        @Override
-        public int arity() {
-                return parameters.size();
-        }
-
-        public List<DNFAnd> getClauses() {
-                return clauses;
-        }
-
-        public static Builder builder() {
-                return builder(null);
-        }
-
-        public static Builder builder(String name) {
-                return new Builder(name);
-        }
-
-        @SuppressWarnings("UnusedReturnValue")
-        public static class Builder {
-                private final String name;
-
-                private final List<Variable> parameters = new ArrayList<>();
-
-                private final List<FunctionalDependency<Variable>> functionalDependencies = new ArrayList<>();
-
-                private final List<List<DNFAtom>> clauses = new ArrayList<>();
-
-                private Builder(String name) {
-                        this.name = name;
-                }
-
-                public Builder parameter(Variable variable) {
-                        parameters.add(variable);
-                        return this;
-                }
-
-                public Builder parameters(Variable... variables) {
-                        return parameters(List.of(variables));
-                }
-
-                public Builder parameters(Collection<Variable> variables) {
-                        parameters.addAll(variables);
-                        return this;
-                }
-
-                public Builder functionalDependencies(Collection<FunctionalDependency<Variable>> functionalDependencies) {
-                        this.functionalDependencies.addAll(functionalDependencies);
-                        return this;
-                }
-
-                public Builder functionalDependency(FunctionalDependency<Variable> functionalDependency) {
-                        functionalDependencies.add(functionalDependency);
-                        return this;
-                }
-
-                public Builder functionalDependency(Set<Variable> forEach, Set<Variable> unique) {
-                        return functionalDependency(new FunctionalDependency<>(forEach, unique));
-                }
-
-                public Builder clause(DNFAtom... atoms) {
-                        clauses.add(List.of(atoms));
-                        return this;
-                }
-
-                public Builder clause(Collection<DNFAtom> atoms) {
-                        clauses.add(List.copyOf(atoms));
-                        return this;
-                }
-
-                public Builder clause(DNFAnd clause) {
-                        return clause(clause.constraints());
-                }
-
-                public Builder clauses(DNFAnd... clauses) {
-                        for (var clause : clauses) {
-                                this.clause(clause);
-                        }
-                        return this;
-                }
-
-                public Builder clauses(Collection<DNFAnd> clauses) {
-                        for (var clause : clauses) {
-                                this.clause(clause);
-                        }
-                        return this;
-                }
-
-                public DNF build() {
-                        var postProcessedClauses = new ArrayList<DNFAnd>();
-                        for (var constraints : clauses) {
-                                var variables = new HashSet<Variable>();
-                                for (var constraint : constraints) {
-                                        constraint.collectAllVariables(variables);
-                                }
-                                parameters.forEach(variables::remove);
-                                postProcessedClauses.add(new DNFAnd(Collections.unmodifiableSet(variables),
-                                                Collections.unmodifiableList(constraints)));
-                        }
-                        return new DNF(name, Collections.unmodifiableList(parameters),
-                                        Collections.unmodifiableList(functionalDependencies),
-                                        Collections.unmodifiableList(postProcessedClauses));
-                }
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/DNFAnd.java b/subprojects/store/src/main/java/tools/refinery/store/query/DNFAnd.java
deleted file mode 100644
index 8c3bf05d..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/DNFAnd.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package tools.refinery.store.query;
-
-import tools.refinery.store.query.atom.DNFAtom;
-
-import java.util.List;
-import java.util.Set;
-
-public record DNFAnd(Set<Variable> quantifiedVariables, List<DNFAtom> constraints) {
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/RelationLike.java b/subprojects/store/src/main/java/tools/refinery/store/query/RelationLike.java
deleted file mode 100644
index 8c784d8b..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/RelationLike.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package tools.refinery.store.query;
-
-public interface RelationLike {
-        String name();
-
-        int arity();
-
-        default boolean invalidIndex(int i) {
-                return i < 0 || i >= arity();
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/ResultSet.java b/subprojects/store/src/main/java/tools/refinery/store/query/ResultSet.java
deleted file mode 100644
index 3542e252..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/ResultSet.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package tools.refinery.store.query;
-
-import tools.refinery.store.tuple.Tuple;
-import tools.refinery.store.tuple.TupleLike;
-
-import java.util.Optional;
-import java.util.stream.Stream;
-
-public interface ResultSet {
-        boolean hasResult();
-
-        boolean hasResult(Tuple parameters);
-
-        Optional<TupleLike> oneResult();
-
-        Optional<TupleLike> oneResult(Tuple parameters);
-
-        Stream<TupleLike> allResults();
-
-        Stream<TupleLike> allResults(Tuple parameters);
-
-        int countResults();
-
-        int countResults(Tuple parameters);
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/Variable.java b/subprojects/store/src/main/java/tools/refinery/store/query/Variable.java
deleted file mode 100644
index 3632f3c5..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/Variable.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package tools.refinery.store.query;
-
-import java.util.Objects;
-
-public class Variable {
-        private final String name;
-        private final String uniqueName;
-
-        public Variable() {
-                this(null);
-        }
-
-        public Variable(String name) {
-                super();
-                this.name = name;
-                this.uniqueName = DNFUtils.generateUniqueName(name);
-
-        }
-        public String getName() {
-                return name;
-        }
-
-        public String getUniqueName() {
-                return uniqueName;
-        }
-
-        public boolean isNamed() {
-                return name != null;
-        }
-
-        @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);
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallAtom.java
deleted file mode 100644
index 47121870..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallAtom.java
+++ /dev/null
@@ -1,80 +0,0 @@
-package tools.refinery.store.query.atom;
-
-import tools.refinery.store.query.Variable;
-import tools.refinery.store.query.RelationLike;
-
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
-
-public abstract class CallAtom<T extends RelationLike> implements DNFAtom {
-        private final CallPolarity polarity;
-        private final T target;
-        private final List<Variable> substitution;
-
-        protected CallAtom(CallPolarity polarity, T target, List<Variable> substitution) {
-                if (substitution.size() != target.arity()) {
-                        throw new IllegalArgumentException("%s needs %d arguments, but got %s".formatted(target.name(),
-                                        target.arity(), substitution.size()));
-                }
-                if (polarity.isTransitive() && target.arity() != 2) {
-                        throw new IllegalArgumentException("Transitive closures can only take binary relations");
-                }
-                this.polarity = polarity;
-                this.target = target;
-                this.substitution = substitution;
-        }
-
-        protected CallAtom(CallPolarity polarity, T target, Variable... substitution) {
-                this(polarity, target, List.of(substitution));
-        }
-
-        protected CallAtom(boolean positive, T target, List<Variable> substitution) {
-                this(CallPolarity.fromBoolean(positive), target, substitution);
-        }
-
-        protected CallAtom(boolean positive, T target, Variable... substitution) {
-                this(positive, target, List.of(substitution));
-        }
-
-        protected CallAtom(T target, List<Variable> substitution) {
-                this(true, target, substitution);
-        }
-
-        protected CallAtom(T target, Variable... substitution) {
-                this(target, List.of(substitution));
-        }
-
-        public CallPolarity getPolarity() {
-                return polarity;
-        }
-
-        public T getTarget() {
-                return target;
-        }
-
-        public List<Variable> getSubstitution() {
-                return substitution;
-        }
-
-        @Override
-        public void collectAllVariables(Set<Variable> variables) {
-                if (polarity.isPositive()) {
-                        variables.addAll(substitution);
-                }
-        }
-
-        @Override
-        public boolean equals(Object o) {
-                if (this == o) return true;
-                if (o == null || getClass() != o.getClass()) return false;
-                CallAtom<?> callAtom = (CallAtom<?>) o;
-                return polarity == callAtom.polarity && Objects.equals(target, callAtom.target) && Objects.equals(substitution
-                                , callAtom.substitution);
-        }
-
-        @Override
-        public int hashCode() {
-                return Objects.hash(polarity, target, substitution);
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/ConstantAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/ConstantAtom.java
deleted file mode 100644
index 13dae7d0..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/ConstantAtom.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package tools.refinery.store.query.atom;
-
-import tools.refinery.store.query.Variable;
-
-import java.util.Set;
-
-public record ConstantAtom(Variable variable, int nodeId) implements DNFAtom {
-        @Override
-        public void collectAllVariables(Set<Variable> variables) {
-                variables.add(variable);
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/DNFAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/DNFAtom.java
deleted file mode 100644
index ebf71236..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/DNFAtom.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package tools.refinery.store.query.atom;
-
-import tools.refinery.store.query.Variable;
-
-import java.util.Set;
-
-public interface DNFAtom {
-        void collectAllVariables(Set<Variable> variables);
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/DNFCallAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/DNFCallAtom.java
deleted file mode 100644
index 3b4f5cd1..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/DNFCallAtom.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package tools.refinery.store.query.atom;
-
-import tools.refinery.store.query.DNF;
-import tools.refinery.store.query.Variable;
-
-import java.util.List;
-
-public class DNFCallAtom extends CallAtom<DNF> {
-        public DNFCallAtom(CallPolarity polarity, DNF target, List<Variable> substitution) {
-                super(polarity, target, substitution);
-        }
-
-        public DNFCallAtom(CallPolarity polarity, DNF target, Variable... substitution) {
-                super(polarity, target, substitution);
-        }
-
-        public DNFCallAtom(boolean positive, DNF target, List<Variable> substitution) {
-                super(positive, target, substitution);
-        }
-
-        public DNFCallAtom(boolean positive, DNF target, Variable... substitution) {
-                super(positive, target, substitution);
-        }
-
-        public DNFCallAtom(DNF target, List<Variable> substitution) {
-                super(target, substitution);
-        }
-
-        public DNFCallAtom(DNF target, Variable... substitution) {
-                super(target, substitution);
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/EquivalenceAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/EquivalenceAtom.java
deleted file mode 100644
index b1b3a6f7..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/EquivalenceAtom.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package tools.refinery.store.query.atom;
-
-import tools.refinery.store.query.Variable;
-
-import java.util.Set;
-
-public record EquivalenceAtom(boolean positive, Variable left, Variable right) implements DNFAtom {
-        public EquivalenceAtom(Variable left, Variable right) {
-                this(true, left, right);
-        }
-
-        @Override
-        public void collectAllVariables(Set<Variable> variables) {
-                variables.add(left);
-                variables.add(right);
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationViewAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationViewAtom.java
deleted file mode 100644
index a2b176c4..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationViewAtom.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package tools.refinery.store.query.atom;
-
-import tools.refinery.store.query.Variable;
-import tools.refinery.store.query.view.AnyRelationView;
-
-import java.util.List;
-
-public final class RelationViewAtom extends CallAtom<AnyRelationView> {
-        public RelationViewAtom(CallPolarity polarity, AnyRelationView target, List<Variable> substitution) {
-                super(polarity, target, substitution);
-        }
-
-        public RelationViewAtom(CallPolarity polarity, AnyRelationView target, Variable... substitution) {
-                super(polarity, target, substitution);
-        }
-
-        public RelationViewAtom(boolean positive, AnyRelationView target, List<Variable> substitution) {
-                super(positive, target, substitution);
-        }
-
-        public RelationViewAtom(boolean positive, AnyRelationView target, Variable... substitution) {
-                super(positive, target, substitution);
-        }
-
-        public RelationViewAtom(AnyRelationView target, List<Variable> substitution) {
-                super(target, substitution);
-        }
-
-        public RelationViewAtom(AnyRelationView target, Variable... substitution) {
-                super(target, substitution);
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/AbstractDomain.java b/subprojects/store/src/main/java/tools/refinery/store/representation/AbstractDomain.java
new file mode 100644
index 00000000..18903ead
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/AbstractDomain.java
@@ -0,0 +1,29 @@
+package tools.refinery.store.representation;
+
+import java.util.Optional;
+
+public non-sealed interface AbstractDomain<A, C> extends AnyAbstractDomain {
+        @Override
+        Class<A> abstractType();
+
+        @Override
+        Class<C> concreteType();
+
+        A toAbstract(C concreteValue);
+
+        Optional<C> toConcrete(A abstractValue);
+
+        default boolean isConcrete(A abstractValue) {
+                return toConcrete(abstractValue).isPresent();
+        }
+
+        boolean isRefinement(A originalValue, A refinedValue);
+
+        A commonRefinement(A leftValue, A rightValue);
+
+        A commonAncestor(A leftValue, A rightValue);
+
+        A unknown();
+
+        boolean isError(A abstractValue);
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/AnyAbstractDomain.java b/subprojects/store/src/main/java/tools/refinery/store/representation/AnyAbstractDomain.java
new file mode 100644
index 00000000..4c428a1e
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/AnyAbstractDomain.java
@@ -0,0 +1,7 @@
+package tools.refinery.store.representation;
+
+public sealed interface AnyAbstractDomain permits AbstractDomain {
+        Class<?> abstractType();
+
+        Class<?> concreteType();
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/Symbol.java b/subprojects/store/src/main/java/tools/refinery/store/representation/Symbol.java
index 85ea15f4..30b1c03f 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/representation/Symbol.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/Symbol.java
@@ -1,12 +1,6 @@
 package tools.refinery.store.representation;
 
-import java.util.Objects;
-
 public record Symbol<T>(String name, int arity, Class<T> valueType, T defaultValue) implements AnySymbol {
-        public boolean isDefaultValue(T value) {
-                return Objects.equals(defaultValue, value);
-        }
-
         @Override
         public boolean equals(Object o) {
                 return this == o;
diff --git a/subprojects/store/src/main/java/tools/refinery/store/representation/TruthValueDomain.java b/subprojects/store/src/main/java/tools/refinery/store/representation/TruthValueDomain.java
new file mode 100644
index 00000000..29858bce
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/representation/TruthValueDomain.java
@@ -0,0 +1,60 @@
+package tools.refinery.store.representation;
+
+import java.util.Optional;
+
+public final class TruthValueDomain implements AbstractDomain<TruthValue, Boolean> {
+        public static final TruthValueDomain INSTANCE = new TruthValueDomain();
+
+        private TruthValueDomain() {
+        }
+
+        @Override
+        public Class<TruthValue> abstractType() {
+                return null;
+        }
+
+        @Override
+        public Class<Boolean> concreteType() {
+                return null;
+        }
+
+        @Override
+        public TruthValue toAbstract(Boolean concreteValue) {
+                return null;
+        }
+
+        @Override
+        public Optional<Boolean> toConcrete(TruthValue abstractValue) {
+                return Optional.empty();
+        }
+
+        @Override
+        public boolean isConcrete(TruthValue abstractValue) {
+                return AbstractDomain.super.isConcrete(abstractValue);
+        }
+
+        @Override
+        public boolean isRefinement(TruthValue originalValue, TruthValue refinedValue) {
+                return false;
+        }
+
+        @Override
+        public TruthValue commonRefinement(TruthValue leftValue, TruthValue rightValue) {
+                return null;
+        }
+
+        @Override
+        public TruthValue commonAncestor(TruthValue leftValue, TruthValue rightValue) {
+                return null;
+        }
+
+        @Override
+        public TruthValue unknown() {
+                return null;
+        }
+
+        @Override
+        public boolean isError(TruthValue abstractValue) {
+                return false;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/tuple/TupleLike.java b/subprojects/store/src/main/java/tools/refinery/store/tuple/TupleLike.java
index 470ca298..953ea9f8 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/tuple/TupleLike.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/tuple/TupleLike.java
@@ -1,5 +1,8 @@
 package tools.refinery.store.tuple;
 
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
 public interface TupleLike {
         int getSize();
 
@@ -22,4 +25,11 @@ public interface TupleLike {
                         default -> Tuple.of(toArray());
                 };
         }
+
+        static String toString(TupleLike tuple) {
+                var valuesString = IntStream.range(0, tuple.getSize())
+                                .mapToObj(i -> Integer.toString(tuple.get(i)))
+                                .collect(Collectors.joining(", "));
+                return "[" + valuesString + "]";
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/tuple/TupleN.java b/subprojects/store/src/main/java/tools/refinery/store/tuple/TupleN.java
index 15fd063b..c3aed847 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/tuple/TupleN.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/tuple/TupleN.java
@@ -1,7 +1,6 @@
 package tools.refinery.store.tuple;
 
 import java.util.Arrays;
-import java.util.stream.Collectors;
 
 public record TupleN(int[] values) implements Tuple {
         static final int CUSTOM_TUPLE_SIZE = 2;
@@ -29,8 +28,7 @@ public record TupleN(int[] values) implements Tuple {
 
         @Override
         public String toString() {
-                var valuesString = Arrays.stream(values).mapToObj(Integer::toString).collect(Collectors.joining(", "));
-                return "[" + valuesString + "]";
+                return TupleLike.toString(this);
         }
 
         @Override
diff --git a/subprojects/store/src/main/java/tools/refinery/store/util/CycleDetectingMapper.java b/subprojects/store/src/main/java/tools/refinery/store/util/CycleDetectingMapper.java
new file mode 100644
index 00000000..8a151d01
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/util/CycleDetectingMapper.java
@@ -0,0 +1,52 @@
+package tools.refinery.store.util;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class CycleDetectingMapper<T, R> {
+        private static final String SEPARATOR = " -> ";
+
+        private final Function<T, String> getName;
+
+        private final Function<T, R> doMap;
+
+        private final Set<T> inProgress = new LinkedHashSet<>();
+
+        private final Map<T, R> results = new HashMap<>();
+
+        public CycleDetectingMapper(Function<T, String> getName, Function<T, R> doMap) {
+                this.getName = getName;
+                this.doMap = doMap;
+        }
+
+        public R map(T input) {
+                if (inProgress.contains(input)) {
+                        var path = inProgress.stream().map(getName).collect(Collectors.joining(SEPARATOR));
+                        throw new IllegalArgumentException("Circular reference %s%s%s detected".formatted(path, SEPARATOR,
+                                        getName.apply(input)));
+                }
+                // We can't use computeIfAbsent here, because translating referenced queries calls this method in a reentrant
+                // way, which would cause a ConcurrentModificationException with computeIfAbsent.
+                @SuppressWarnings("squid:S3824")
+                var result = results.get(input);
+                if (result == null) {
+                        inProgress.add(input);
+                        try {
+                                result = doMap.apply(input);
+                                results.put(input, result);
+                        } finally {
+                                inProgress.remove(input);
+                        }
+                }
+                return result;
+        }
+
+        public List<T> getInProgress() {
+                return List.copyOf(inProgress);
+        }
+
+        public R getAlreadyMapped(T input) {
+                return results.get(input);
+        }
+}
diff --git a/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java b/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
index 371b5e47..9536a444 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/model/tests/ModelTest.java
@@ -49,7 +49,7 @@ class ModelTest {
 
                 assertEquals(3, ageInterpretation.get(Tuple.of(0)));
                 assertEquals(1, ageInterpretation.get(Tuple.of(1)));
-                assertNull(ageInterpretation.get( Tuple.of(2)));
+                assertNull(ageInterpretation.get(Tuple.of(2)));
 
                 assertTrue(friendInterpretation.get(Tuple.of(0, 1)));
                 assertFalse(friendInterpretation.get(Tuple.of(0, 5)));